file_name stringlengths 5 52 | name stringlengths 4 95 | original_source_type stringlengths 0 23k | source_type stringlengths 9 23k | source_definition stringlengths 9 57.9k | source dict | source_range dict | file_context stringlengths 0 721k | dependencies dict | opens_and_abbrevs listlengths 2 94 | vconfig dict | interleaved bool 1
class | verbose_type stringlengths 1 7.42k | effect stringclasses 118
values | effect_flags listlengths 0 2 | mutual_with listlengths 0 11 | ideal_premises listlengths 0 236 | proof_features listlengths 0 1 | is_simple_lemma bool 2
classes | is_div bool 2
classes | is_proof bool 2
classes | is_simply_typed bool 2
classes | is_type bool 2
classes | partial_definition stringlengths 5 3.99k | completed_definiton stringlengths 1 1.63M | isa_cross_project_example bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
BinomialQueue.fst | BinomialQueue.tree_root_is_max_aux | val tree_root_is_max_aux (d: nat) (upper_bound: key_t) (t: tree)
: Lemma (requires pow2heap_pred d upper_bound t)
(ensures max upper_bound (keys_of_tree t).ms_elems)
(decreases t) | val tree_root_is_max_aux (d: nat) (upper_bound: key_t) (t: tree)
: Lemma (requires pow2heap_pred d upper_bound t)
(ensures max upper_bound (keys_of_tree t).ms_elems)
(decreases t) | let rec tree_root_is_max_aux (d:nat) (upper_bound:key_t) (t:tree)
: Lemma
(requires pow2heap_pred d upper_bound t)
(ensures max upper_bound (keys_of_tree t).ms_elems)
(decreases t) =
match t with
| Leaf -> ()
| Internal left k right ->
tree_root_is_max_aux (d - 1) k left;
tree_root_is... | {
"file_name": "examples/data_structures/BinomialQueue.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 546,
"start_col": 0,
"start_line": 536
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "BinomialQueue.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prim... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | d: Prims.nat -> upper_bound: BinomialQueue.key_t -> t: BinomialQueue.tree
-> FStar.Pervasives.Lemma (requires BinomialQueue.pow2heap_pred d upper_bound t)
(ensures BinomialQueue.max upper_bound (Mkms?.ms_elems (BinomialQueue.keys_of_tree t)))
(decreases t) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.nat",
"BinomialQueue.key_t",
"BinomialQueue.tree",
"BinomialQueue.tree_root_is_max_aux",
"Prims.op_Subtraction",
"Prims.unit",
"BinomialQueue.pow2heap_pred",
"Prims.squash",
"BinomialQueue.max",
"BinomialQueue.__proj__Mkms__item__ms_elems",
"BinomialQueue.keys_of_tree",
"Prims.Nil",
"... | [
"recursion"
] | false | false | true | false | false | let rec tree_root_is_max_aux (d: nat) (upper_bound: key_t) (t: tree)
: Lemma (requires pow2heap_pred d upper_bound t)
(ensures max upper_bound (keys_of_tree t).ms_elems)
(decreases t) =
| match t with
| Leaf -> ()
| Internal left k right ->
tree_root_is_max_aux (d - 1) k left;
tree_root_is_max_aux (d - 1) upper_bound right | false |
BinomialQueue.fst | BinomialQueue.last_key_in_keys | val last_key_in_keys (l: forest)
: Lemma (requires Cons? l /\ Internal? (L.last l))
(ensures
(let Internal _ k _ = L.last l in
S.subset (S.singleton k) (keys l).ms_elems)) | val last_key_in_keys (l: forest)
: Lemma (requires Cons? l /\ Internal? (L.last l))
(ensures
(let Internal _ k _ = L.last l in
S.subset (S.singleton k) (keys l).ms_elems)) | let rec last_key_in_keys (l:forest)
: Lemma
(requires
Cons? l /\
Internal? (L.last l))
(ensures (let Internal _ k _ = L.last l in
S.subset (S.singleton k) (keys l).ms_elems)) =
match l with
| [Internal _ _ _] -> ()
| _::tl -> last_key_in_keys tl | {
"file_name": "examples/data_structures/BinomialQueue.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 450,
"start_col": 0,
"start_line": 441
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "BinomialQueue.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prim... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: BinomialQueue.forest
-> FStar.Pervasives.Lemma (requires Cons? l /\ Internal? (FStar.List.Tot.Base.last l))
(ensures
(let _ = FStar.List.Tot.Base.last l in
(let BinomialQueue.Internal _ k _ = _ in
FStar.Set.subset (FStar.Set.singleton k) (Mkms?.ms_elems (BinomialQueue.keys l)))
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"BinomialQueue.forest",
"BinomialQueue.tree",
"BinomialQueue.key_t",
"Prims.list",
"BinomialQueue.last_key_in_keys",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Cons",
"BinomialQueue.uu___is_Internal",
"FStar.List.Tot.Base.last",
"Prims.squash",
"FStar.Set.subset",
"FStar.Set.... | [
"recursion"
] | false | false | true | false | false | let rec last_key_in_keys (l: forest)
: Lemma (requires Cons? l /\ Internal? (L.last l))
(ensures
(let Internal _ k _ = L.last l in
S.subset (S.singleton k) (keys l).ms_elems)) =
| match l with
| [Internal _ _ _] -> ()
| _ :: tl -> last_key_in_keys tl | false |
BinomialQueue.fst | BinomialQueue.delete_max_none_repr | val delete_max_none_repr (p:priq)
: Lemma (delete_max p == None <==> p `repr` ms_empty) | val delete_max_none_repr (p:priq)
: Lemma (delete_max p == None <==> p `repr` ms_empty) | let delete_max_none_repr p =
let delete_max_none_repr_l (l:priq)
: Lemma
(requires l `repr` ms_empty)
(ensures delete_max l == None)
[SMTPat ()] = find_max_emp_repr_l l in
let delete_max_none_repr_r (l:priq)
: Lemma
(requires delete_max l == None)
(ensures l `repr` m... | {
"file_name": "examples/data_structures/BinomialQueue.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 4,
"end_line": 494,
"start_col": 0,
"start_line": 482
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "BinomialQueue.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prim... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: BinomialQueue.priq
-> FStar.Pervasives.Lemma
(ensures
BinomialQueue.delete_max p == FStar.Pervasives.Native.None <==>
BinomialQueue.repr p BinomialQueue.ms_empty) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"BinomialQueue.priq",
"Prims.unit",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"BinomialQueue.key_t",
"BinomialQueue.delete_max",
"FStar.Pervasives.Native.None",
"Prims.squash",
"BinomialQueue.repr",
"BinomialQueue.ms_empty",
"Prims.Cons",
"FStar.Pervasi... | [] | false | false | true | false | false | let delete_max_none_repr p =
| let delete_max_none_repr_l (l: priq)
: Lemma (requires l `repr` ms_empty) (ensures delete_max l == None) [SMTPat ()] =
find_max_emp_repr_l l
in
let delete_max_none_repr_r (l: priq)
: Lemma (requires delete_max l == None) (ensures l `repr` ms_empty) [SMTPat ()] =
find_max_emp_repr_r l
in
() | false |
BinomialQueue.fst | BinomialQueue.unzip_repr | val unzip_repr (d: nat) (upper_bound: key_t) (t: tree) (lt: ms)
: Lemma (requires pow2heap_pred d upper_bound t /\ permutation (keys_of_tree t) lt)
(ensures permutation lt (keys (unzip d upper_bound t)))
(decreases t) | val unzip_repr (d: nat) (upper_bound: key_t) (t: tree) (lt: ms)
: Lemma (requires pow2heap_pred d upper_bound t /\ permutation (keys_of_tree t) lt)
(ensures permutation lt (keys (unzip d upper_bound t)))
(decreases t) | let rec unzip_repr (d:nat) (upper_bound:key_t) (t:tree) (lt:ms)
: Lemma
(requires
pow2heap_pred d upper_bound t /\
permutation (keys_of_tree t) lt)
(ensures permutation lt (keys (unzip d upper_bound t)))
(decreases t) =
match t with
| Leaf -> ()
| Internal left k right ->
... | {
"file_name": "examples/data_structures/BinomialQueue.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 520,
"start_col": 0,
"start_line": 505
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "BinomialQueue.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prim... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | d: Prims.nat -> upper_bound: BinomialQueue.key_t -> t: BinomialQueue.tree -> lt: BinomialQueue.ms
-> FStar.Pervasives.Lemma
(requires
BinomialQueue.pow2heap_pred d upper_bound t /\
BinomialQueue.permutation (BinomialQueue.keys_of_tree t) lt)
(ensures
BinomialQueue.permutation lt (B... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.nat",
"BinomialQueue.key_t",
"BinomialQueue.tree",
"BinomialQueue.ms",
"BinomialQueue.keys_append",
"Prims.Cons",
"BinomialQueue.Internal",
"BinomialQueue.Leaf",
"Prims.Nil",
"BinomialQueue.keys_of_tree",
"BinomialQueue.ms_append",
"BinomialQueue.ms_singleton",
"BinomialQueue.ms_empty... | [
"recursion"
] | false | false | true | false | false | let rec unzip_repr (d: nat) (upper_bound: key_t) (t: tree) (lt: ms)
: Lemma (requires pow2heap_pred d upper_bound t /\ permutation (keys_of_tree t) lt)
(ensures permutation lt (keys (unzip d upper_bound t)))
(decreases t) =
| match t with
| Leaf -> ()
| Internal left k right ->
let q = unzip (d - 1) upper_bound right in
unzip_repr (d - 1) upper_bound right (keys_of_tree right);
keys_append q
[Internal left k Leaf]
(keys_of_tree right)
(ms_append (keys_of_tree left) (ms_append (ms_singleton k) ms_empty)) | false |
BinomialQueue.fst | BinomialQueue.heap_delete_max_repr | val heap_delete_max_repr (d: pos) (t: tree) (lt: ms)
: Lemma (requires is_pow2heap d t /\ t `repr_t` lt)
(ensures
(let Internal left k Leaf = t in
permutation lt (ms_append (ms_singleton k) (keys (heap_delete_max d t))))) | val heap_delete_max_repr (d: pos) (t: tree) (lt: ms)
: Lemma (requires is_pow2heap d t /\ t `repr_t` lt)
(ensures
(let Internal left k Leaf = t in
permutation lt (ms_append (ms_singleton k) (keys (heap_delete_max d t))))) | let heap_delete_max_repr (d:pos) (t:tree) (lt:ms)
: Lemma
(requires is_pow2heap d t /\ t `repr_t` lt)
(ensures (
let Internal left k Leaf = t in
permutation lt (ms_append (ms_singleton k)
(keys (heap_delete_max d t))))) =
let Internal left k Leaf = t... | {
"file_name": "examples/data_structures/BinomialQueue.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 531,
"start_col": 0,
"start_line": 522
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "BinomialQueue.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prim... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | d: Prims.pos -> t: BinomialQueue.tree -> lt: BinomialQueue.ms
-> FStar.Pervasives.Lemma (requires BinomialQueue.is_pow2heap d t /\ BinomialQueue.repr_t t lt)
(ensures
(let _ = t in
(let BinomialQueue.Internal _ k BinomialQueue.Leaf = _ in
BinomialQueue.permutation lt
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"BinomialQueue.tree",
"BinomialQueue.ms",
"BinomialQueue.key_t",
"BinomialQueue.unzip_repr",
"Prims.op_Subtraction",
"BinomialQueue.keys_of_tree",
"Prims.unit",
"Prims.l_and",
"BinomialQueue.is_pow2heap",
"BinomialQueue.repr_t",
"Prims.squash",
"BinomialQueue.permutation",
"Bi... | [] | false | false | true | false | false | let heap_delete_max_repr (d: pos) (t: tree) (lt: ms)
: Lemma (requires is_pow2heap d t /\ t `repr_t` lt)
(ensures
(let Internal left k Leaf = t in
permutation lt (ms_append (ms_singleton k) (keys (heap_delete_max d t))))) =
| let Internal left k Leaf = t in
unzip_repr (d - 1) k left (keys_of_tree left) | false |
BinomialQueue.fst | BinomialQueue.keys_append | val keys_append (l1 l2: forest) (ms1 ms2: ms)
: Lemma (requires l1 `repr_l` ms1 /\ l2 `repr_l` ms2)
(ensures (L.append l1 l2) `repr_l` (ms_append ms1 ms2)) | val keys_append (l1 l2: forest) (ms1 ms2: ms)
: Lemma (requires l1 `repr_l` ms1 /\ l2 `repr_l` ms2)
(ensures (L.append l1 l2) `repr_l` (ms_append ms1 ms2)) | let rec keys_append (l1 l2:forest) (ms1 ms2:ms)
: Lemma (requires l1 `repr_l` ms1 /\ l2 `repr_l` ms2)
(ensures (L.append l1 l2) `repr_l` (ms_append ms1 ms2)) =
match l1 with
| [] -> ()
| _::tl -> keys_append tl l2 (keys tl) ms2 | {
"file_name": "examples/data_structures/BinomialQueue.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 503,
"start_col": 0,
"start_line": 497
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "BinomialQueue.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prim... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
l1: BinomialQueue.forest ->
l2: BinomialQueue.forest ->
ms1: BinomialQueue.ms ->
ms2: BinomialQueue.ms
-> FStar.Pervasives.Lemma (requires BinomialQueue.repr_l l1 ms1 /\ BinomialQueue.repr_l l2 ms2)
(ensures BinomialQueue.repr_l (l1 @ l2) (BinomialQueue.ms_append ms1 ms2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"BinomialQueue.forest",
"BinomialQueue.ms",
"BinomialQueue.tree",
"Prims.list",
"BinomialQueue.keys_append",
"BinomialQueue.keys",
"Prims.unit",
"Prims.l_and",
"BinomialQueue.repr_l",
"Prims.squash",
"FStar.List.Tot.Base.append",
"BinomialQueue.ms_append",
"Prims.Nil",
"FStar.Pervasives.pa... | [
"recursion"
] | false | false | true | false | false | let rec keys_append (l1 l2: forest) (ms1 ms2: ms)
: Lemma (requires l1 `repr_l` ms1 /\ l2 `repr_l` ms2)
(ensures (L.append l1 l2) `repr_l` (ms_append ms1 ms2)) =
| match l1 with
| [] -> ()
| _ :: tl -> keys_append tl l2 (keys tl) ms2 | false |
BinomialQueue.fst | BinomialQueue.find_max_is_max | val find_max_is_max (d: pos) (kopt: option key_t) (q: forest)
: Lemma (requires is_binomial_queue d q /\ Some? (find_max kopt q))
(ensures
(let Some k = find_max kopt q in
max k (keys q).ms_elems))
(decreases q) | val find_max_is_max (d: pos) (kopt: option key_t) (q: forest)
: Lemma (requires is_binomial_queue d q /\ Some? (find_max kopt q))
(ensures
(let Some k = find_max kopt q in
max k (keys q).ms_elems))
(decreases q) | let rec find_max_is_max (d:pos) (kopt:option key_t) (q:forest)
: Lemma
(requires
is_binomial_queue d q /\
Some? (find_max kopt q))
(ensures
(let Some k = find_max kopt q in
max k (keys q).ms_elems))
(decreases q) =
match q with
| [] -> ()
| Leaf::q ->
f... | {
"file_name": "examples/data_structures/BinomialQueue.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 629,
"start_col": 0,
"start_line": 607
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "BinomialQueue.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prim... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | d: Prims.pos -> kopt: FStar.Pervasives.Native.option BinomialQueue.key_t -> q: BinomialQueue.forest
-> FStar.Pervasives.Lemma
(requires BinomialQueue.is_binomial_queue d q /\ Some? (BinomialQueue.find_max kopt q))
(ensures
(let _ = BinomialQueue.find_max kopt q in
(let FStar.Pervasives.N... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.pos",
"FStar.Pervasives.Native.option",
"BinomialQueue.key_t",
"BinomialQueue.forest",
"Prims.list",
"BinomialQueue.tree",
"BinomialQueue.find_max_is_max",
"Prims.op_Addition",
"BinomialQueue.find_max_some_is_some",
"Prims.unit",
"FStar.Pervasives.Native.Some",
"Prims.op_LessThan",
"P... | [
"recursion"
] | false | false | true | false | false | let rec find_max_is_max (d: pos) (kopt: option key_t) (q: forest)
: Lemma (requires is_binomial_queue d q /\ Some? (find_max kopt q))
(ensures
(let Some k = find_max kopt q in
max k (keys q).ms_elems))
(decreases q) =
| match q with
| [] -> ()
| Leaf :: q -> find_max_is_max (d + 1) kopt q
| Internal left k Leaf :: tl ->
tree_root_is_max d (Internal left k Leaf);
match kopt with
| None ->
find_max_is_max (d + 1) (Some k) tl;
find_max_some_is_some k tl
| Some k' ->
let k = if k' < k then k else k' in
find_max_is_... | false |
BinomialQueue.fst | BinomialQueue.merge_repr | val merge_repr (p q:priq) (sp sq:ms)
: Lemma (requires p `repr` sp /\ q `repr` sq)
(ensures merge p q `repr` ms_append sp sq) | val merge_repr (p q:priq) (sp sq:ms)
: Lemma (requires p `repr` sp /\ q `repr` sq)
(ensures merge p q `repr` ms_append sp sq) | let merge_repr p q sp sq =
join_repr 1 p q Leaf sp sq ms_empty | {
"file_name": "examples/data_structures/BinomialQueue.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 437,
"start_col": 0,
"start_line": 436
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "BinomialQueue.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prim... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: BinomialQueue.priq -> q: BinomialQueue.priq -> sp: BinomialQueue.ms -> sq: BinomialQueue.ms
-> FStar.Pervasives.Lemma (requires BinomialQueue.repr p sp /\ BinomialQueue.repr q sq)
(ensures BinomialQueue.repr (BinomialQueue.merge p q) (BinomialQueue.ms_append sp sq)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"BinomialQueue.priq",
"BinomialQueue.ms",
"BinomialQueue.join_repr",
"BinomialQueue.Leaf",
"BinomialQueue.ms_empty",
"Prims.unit"
] | [] | true | false | true | false | false | let merge_repr p q sp sq =
| join_repr 1 p q Leaf sp sq ms_empty | false |
BinomialQueue.fst | BinomialQueue.carry_repr | val carry_repr (d: pos) (q: forest) (t: tree) (lq lt: ms)
: Lemma (requires is_binomial_queue d q /\ is_pow2heap d t /\ q `repr_l` lq /\ t `repr_t` lt)
(ensures (carry d q t) `repr_l` (ms_append lq lt))
(decreases q) | val carry_repr (d: pos) (q: forest) (t: tree) (lq lt: ms)
: Lemma (requires is_binomial_queue d q /\ is_pow2heap d t /\ q `repr_l` lq /\ t `repr_t` lt)
(ensures (carry d q t) `repr_l` (ms_append lq lt))
(decreases q) | let rec carry_repr (d:pos) (q:forest) (t:tree) (lq lt:ms)
: Lemma
(requires
is_binomial_queue d q /\
is_pow2heap d t /\
q `repr_l` lq /\
t `repr_t` lt)
(ensures carry d q t `repr_l` ms_append lq lt)
(decreases q) =
match q with
| [] -> ()
| Leaf::_ -> ()
... | {
"file_name": "examples/data_structures/BinomialQueue.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 52,
"end_line": 359,
"start_col": 0,
"start_line": 342
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "BinomialQueue.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prim... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
d: Prims.pos ->
q: BinomialQueue.forest ->
t: BinomialQueue.tree ->
lq: BinomialQueue.ms ->
lt: BinomialQueue.ms
-> FStar.Pervasives.Lemma
(requires
BinomialQueue.is_binomial_queue d q /\ BinomialQueue.is_pow2heap d t /\
BinomialQueue.repr_l q lq /\ BinomialQueue.repr_t t lt... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.pos",
"BinomialQueue.forest",
"BinomialQueue.tree",
"BinomialQueue.ms",
"Prims.list",
"BinomialQueue.carry_repr",
"Prims.op_Addition",
"BinomialQueue.smash",
"BinomialQueue.keys",
"BinomialQueue.ms_append",
"BinomialQueue.keys_of_tree",
"Prims.unit",
"BinomialQueue.smash_repr",
"Pri... | [
"recursion"
] | false | false | true | false | false | let rec carry_repr (d: pos) (q: forest) (t: tree) (lq lt: ms)
: Lemma (requires is_binomial_queue d q /\ is_pow2heap d t /\ q `repr_l` lq /\ t `repr_t` lt)
(ensures (carry d q t) `repr_l` (ms_append lq lt))
(decreases q) =
| match q with
| [] -> ()
| Leaf :: _ -> ()
| hd :: tl ->
smash_repr d hd t (keys_of_tree hd) (keys_of_tree t);
carry_repr (d + 1) tl (smash d hd t) (keys tl) (ms_append (keys_of_tree hd) (keys_of_tree t)) | false |
BinomialQueue.fst | BinomialQueue.delete_max_aux_repr | val delete_max_aux_repr
(m: key_t)
(d: pos)
(q: forest)
(x: key_t)
(r: forest)
(p: priq)
(lq lr lp: ms)
: Lemma
(requires
S.mem m (keys q).ms_elems /\ is_binomial_queue d q /\ q `repr_l` lq /\
delete_max_aux m d q == (x, r, p) /\ r `repr_l` lr /\ p `re... | val delete_max_aux_repr
(m: key_t)
(d: pos)
(q: forest)
(x: key_t)
(r: forest)
(p: priq)
(lq lr lp: ms)
: Lemma
(requires
S.mem m (keys q).ms_elems /\ is_binomial_queue d q /\ q `repr_l` lq /\
delete_max_aux m d q == (x, r, p) /\ r `repr_l` lr /\ p `re... | let rec delete_max_aux_repr (m:key_t) (d:pos) (q:forest)
(x:key_t) (r:forest) (p:priq)
(lq lr lp:ms)
: Lemma
(requires
S.mem m (keys q).ms_elems /\
is_binomial_queue d q /\
q `repr_l` lq /\
delete_max_aux m d q == (x, r, p) /\
r `repr_l` lr /\
p `repr_l`... | {
"file_name": "examples/data_structures/BinomialQueue.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 92,
"end_line": 586,
"start_col": 0,
"start_line": 558
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "BinomialQueue.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prim... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
m: BinomialQueue.key_t ->
d: Prims.pos ->
q: BinomialQueue.forest ->
x: BinomialQueue.key_t ->
r: BinomialQueue.forest ->
p: BinomialQueue.priq ->
lq: BinomialQueue.ms ->
lr: BinomialQueue.ms ->
lp: BinomialQueue.ms
-> FStar.Pervasives.Lemma
(requires
FStar.Set.mem m... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"BinomialQueue.key_t",
"Prims.pos",
"BinomialQueue.forest",
"BinomialQueue.priq",
"BinomialQueue.ms",
"Prims.list",
"BinomialQueue.tree",
"BinomialQueue.delete_max_aux_repr",
"Prims.op_Addition",
"FStar.List.Tot.Base.tl",
"Prims.op_LessThan",
"BinomialQueue.keys",
"Prims.unit",
"FStar.Perv... | [
"recursion"
] | false | false | true | false | false | let rec delete_max_aux_repr
(m: key_t)
(d: pos)
(q: forest)
(x: key_t)
(r: forest)
(p: priq)
(lq lr lp: ms)
: Lemma
(requires
S.mem m (keys q).ms_elems /\ is_binomial_queue d q /\ q `repr_l` lq /\
delete_max_aux m d q == (x, r, p) /\ r `repr_l` lr /\ p... | match q with
| [] -> ()
| Leaf :: q -> delete_max_aux_repr m (d + 1) q x (L.tl r) p lq lr lp
| Internal left x Leaf :: q ->
if x < m
then
(tree_root_is_max d (Internal left x Leaf);
assert (~(S.mem m (keys_of_tree left).ms_elems));
let y, _, _ = delete_max_aux m (d + 1) q in
delete_max_aux_rep... | false |
Steel.ST.C.Types.Base.fsti | Steel.ST.C.Types.Base.mk_fraction_split | val mk_fraction_split
(#opened: _)
(#t: Type)
(#td: typedef t)
(r: ref td)
(v: Ghost.erased t {fractionable td v})
(p1 p2: P.perm)
: STGhost unit
opened
(pts_to r v)
(fun _ -> (pts_to r (mk_fraction td v p1)) `star` (pts_to r (mk_fraction td v p2)))
(P.ful... | val mk_fraction_split
(#opened: _)
(#t: Type)
(#td: typedef t)
(r: ref td)
(v: Ghost.erased t {fractionable td v})
(p1 p2: P.perm)
: STGhost unit
opened
(pts_to r v)
(fun _ -> (pts_to r (mk_fraction td v p1)) `star` (pts_to r (mk_fraction td v p2)))
(P.ful... | let mk_fraction_split
(#opened: _)
(#t: Type) (#td: typedef t) (r: ref td) (v: Ghost.erased t { fractionable td v }) (p1 p2: P.perm) : STGhost unit opened
(pts_to r v)
(fun _ -> pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
(P.full_perm == p1 `P.sum_perm` p2)
(fun _ -> True)
= mk_fra... | {
"file_name": "lib/steel/c/Steel.ST.C.Types.Base.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 45,
"end_line": 288,
"start_col": 0,
"start_line": 279
} | module Steel.ST.C.Types.Base
open Steel.ST.Util
module P = Steel.FractionalPermission
/// Helper to compose two permissions into one
val prod_perm (p1 p2: P.perm) : Pure P.perm
(requires True)
(ensures (fun p ->
((p1 `P.lesser_equal_perm` P.full_perm /\ p2 `P.lesser_equal_perm` P.full_perm) ==>
p `P.lesse... | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": ... | [
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types",
"short_module": null
},
{
"abbrev": false,
"f... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: Steel.ST.C.Types.Base.ref td ->
v: FStar.Ghost.erased t {Steel.ST.C.Types.Base.fractionable td (FStar.Ghost.reveal v)} ->
p1: Steel.FractionalPermission.perm ->
p2: Steel.FractionalPermission.perm
-> Steel.ST.Effect.Ghost.STGhost Prims.unit | Steel.ST.Effect.Ghost.STGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.ST.C.Types.Base.typedef",
"Steel.ST.C.Types.Base.ref",
"FStar.Ghost.erased",
"Steel.ST.C.Types.Base.fractionable",
"FStar.Ghost.reveal",
"Steel.FractionalPermission.perm",
"Steel.ST.C.Types.Base.mk_fraction_split_gen",
"Steel.FractionalPermission.full_perm",
"Prims.un... | [] | false | true | false | false | false | let mk_fraction_split
(#opened: _)
(#t: Type)
(#td: typedef t)
(r: ref td)
(v: Ghost.erased t {fractionable td v})
(p1 p2: P.perm)
: STGhost unit
opened
(pts_to r v)
(fun _ -> (pts_to r (mk_fraction td v p1)) `star` (pts_to r (mk_fraction td v p2)))
(P.ful... | mk_fraction_full td v;
rewrite (pts_to _ _) (pts_to _ _);
mk_fraction_split_gen r v P.full_perm p1 p2 | false |
BinomialQueue.fst | BinomialQueue.delete_max_some_repr | val delete_max_some_repr (p:priq) (sp:ms)
(k:key_t) (q:priq) (sq:ms)
: Lemma (requires
p `repr` sp /\
delete_max p == Some (k, q) /\
q `repr` sq)
(ensures
permutation sp (ms_cons k sq) /\
(forall (x:key_t). S.mem x sp.ms_elems ==> x <= k)) | val delete_max_some_repr (p:priq) (sp:ms)
(k:key_t) (q:priq) (sq:ms)
: Lemma (requires
p `repr` sp /\
delete_max p == Some (k, q) /\
q `repr` sq)
(ensures
permutation sp (ms_cons k sq) /\
(forall (x:key_t). S.mem x sp.ms_elems ==> x <= k)) | let delete_max_some_repr p pl k q ql =
match find_max None p with
| None -> ()
| Some m ->
find_max_mem_keys None p;
assert (S.mem m (keys p).ms_elems);
let x, q, new_q = delete_max_aux m 1 p in
delete_max_aux_repr m 1 p x q new_q
pl (keys q) (keys new_q);
let r = join 1 q new_q Leaf in
... | {
"file_name": "examples/data_structures/BinomialQueue.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 644,
"start_col": 0,
"start_line": 631
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "BinomialQueue.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prim... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: BinomialQueue.priq ->
sp: BinomialQueue.ms ->
k: BinomialQueue.key_t ->
q: BinomialQueue.priq ->
sq: BinomialQueue.ms
-> FStar.Pervasives.Lemma
(requires
BinomialQueue.repr p sp /\ BinomialQueue.delete_max p == FStar.Pervasives.Native.Some (k, q) /\
BinomialQueue.repr q s... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"BinomialQueue.priq",
"BinomialQueue.ms",
"BinomialQueue.key_t",
"BinomialQueue.find_max",
"FStar.Pervasives.Native.None",
"BinomialQueue.forest",
"BinomialQueue.find_max_is_max",
"Prims.unit",
"Prims._assert",
"BinomialQueue.permutation",
"BinomialQueue.ms_append",
"BinomialQueue.ms_singleton... | [] | false | false | true | false | false | let delete_max_some_repr p pl k q ql =
| match find_max None p with
| None -> ()
| Some m ->
find_max_mem_keys None p;
assert (S.mem m (keys p).ms_elems);
let x, q, new_q = delete_max_aux m 1 p in
delete_max_aux_repr m 1 p x q new_q pl (keys q) (keys new_q);
let r = join 1 q new_q Leaf in
join_repr 1 q new_q Leaf (keys q) (keys new_q) ms_empty;
... | false |
BinomialQueue.fst | BinomialQueue.join_repr | val join_repr (d: pos) (p q: forest) (c: tree) (lp lq lc: ms)
: Lemma
(requires
is_binomial_queue d p /\ is_binomial_queue d q /\ (Leaf? c \/ is_pow2heap d c) /\
p `repr_l` lp /\ q `repr_l` lq /\ c `repr_t` lc)
(ensures (join d p q c) `repr_l` (ms_append lp (ms_append lq lc)))
(dec... | val join_repr (d: pos) (p q: forest) (c: tree) (lp lq lc: ms)
: Lemma
(requires
is_binomial_queue d p /\ is_binomial_queue d q /\ (Leaf? c \/ is_pow2heap d c) /\
p `repr_l` lp /\ q `repr_l` lq /\ c `repr_t` lc)
(ensures (join d p q c) `repr_l` (ms_append lp (ms_append lq lc)))
(dec... | let rec join_repr (d:pos) (p q:forest) (c:tree)
(lp lq lc:ms)
: Lemma
(requires
is_binomial_queue d p /\
is_binomial_queue d q /\
(Leaf? c \/ is_pow2heap d c) /\
p `repr_l` lp /\
q `repr_l` lq /\
c `repr_t` lc)
(ensures join d p q c `repr_l` ms_appen... | {
"file_name": "examples/data_structures/BinomialQueue.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 407,
"start_col": 0,
"start_line": 362
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": true,
"source_file": "BinomialQueue.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Set",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prim... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
d: Prims.pos ->
p: BinomialQueue.forest ->
q: BinomialQueue.forest ->
c: BinomialQueue.tree ->
lp: BinomialQueue.ms ->
lq: BinomialQueue.ms ->
lc: BinomialQueue.ms
-> FStar.Pervasives.Lemma
(requires
BinomialQueue.is_binomial_queue d p /\ BinomialQueue.is_binomial_queue d q ... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.pos",
"BinomialQueue.forest",
"BinomialQueue.tree",
"BinomialQueue.ms",
"FStar.Pervasives.Native.Mktuple3",
"Prims.list",
"BinomialQueue.carry_repr",
"BinomialQueue.join_repr",
"Prims.op_Addition",
"BinomialQueue.Leaf",
"BinomialQueue.keys",
"BinomialQueue.ms_empty",
"BinomialQueue.sm... | [
"recursion"
] | false | false | true | false | false | let rec join_repr (d: pos) (p q: forest) (c: tree) (lp lq lc: ms)
: Lemma
(requires
is_binomial_queue d p /\ is_binomial_queue d q /\ (Leaf? c \/ is_pow2heap d c) /\
p `repr_l` lp /\ q `repr_l` lq /\ c `repr_t` lc)
(ensures (join d p q c) `repr_l` (ms_append lp (ms_append lq lc)))
... | match p, q, c with
| [], _, Leaf | _, [], Leaf -> ()
| [], _, _ -> carry_repr d q c lq lc
| _, [], _ -> carry_repr d p c lp lc
| Leaf :: tl_p, Leaf :: tl_q, _ -> join_repr (d + 1) tl_p tl_q Leaf (keys tl_p) (keys tl_q) ms_empty
| hd_p :: tl_p, Leaf :: tl_q, Leaf ->
join_repr (d + 1) tl_p tl_q Leaf (keys tl_p) (keys t... | false |
Vale.Bignum.X64.fsti | Vale.Bignum.X64.flags_t | val flags_t : Type0 | let flags_t = Vale.X64.Flags.t | {
"file_name": "obj/Vale.Bignum.X64.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 17,
"start_col": 0,
"start_line": 17
} | module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.Bignum.Defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Flags.t"
] | [] | false | false | false | true | true | let flags_t =
| Vale.X64.Flags.t | false | |
Vale.Bignum.X64.fsti | Vale.Bignum.X64.update_cf | val update_cf : f': Vale.Bignum.X64.flags_t -> c: Vale.Def.Words_s.nat1 -> Prims.logical | let update_cf (f':flags_t) (c:nat1) = flag_cf f' == c /\ valid_cf f' | {
"file_name": "obj/Vale.Bignum.X64.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 68,
"end_line": 20,
"start_col": 0,
"start_line": 20
} | module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f': Vale.Bignum.X64.flags_t -> c: Vale.Def.Words_s.nat1 -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Vale.Bignum.X64.flags_t",
"Vale.Def.Words_s.nat1",
"Prims.l_and",
"Prims.eq2",
"Vale.Bignum.X64.flag_cf",
"Prims.b2t",
"Vale.X64.Decls.valid_cf",
"Prims.logical"
] | [] | false | false | false | true | true | let update_cf (f': flags_t) (c: nat1) =
| flag_cf f' == c /\ valid_cf f' | false | |
LListReverse.fst | LListReverse.pop | val pop (#l: Ghost.erased (list U64.t)) (p: ref llist_cell {Cons? l})
: STT (ref llist_cell)
(llist l p)
(fun p' ->
exists_ (fun x ->
((pts_to p full_perm x) `star` (llist (List.Tot.tl l) p'))
`star`
(pure (x.value == List.Tot.hd l)))) | val pop (#l: Ghost.erased (list U64.t)) (p: ref llist_cell {Cons? l})
: STT (ref llist_cell)
(llist l p)
(fun p' ->
exists_ (fun x ->
((pts_to p full_perm x) `star` (llist (List.Tot.tl l) p'))
`star`
(pure (x.value == List.Tot.hd l)))) | let pop
(#l: Ghost.erased (list U64.t))
(p: ref llist_cell { Cons? l })
: STT (ref llist_cell)
(llist l p)
(fun p' -> exists_ (fun x -> pts_to p full_perm x `star` llist (List.Tot.tl l) p' `star` pure (x.value == List.Tot.hd l)))
= rewrite (llist l p) (llist_cons (List.Tot.hd l) (llist (List.Tot.tl l)) p);
... | {
"file_name": "share/steel/tests/krml/LListReverse.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 11,
"end_line": 76,
"start_col": 0,
"start_line": 64
} | module LListReverse
open Steel.ST.GenElim
open Steel.ST.Reference
open Steel.ST.Loops
module U64 = FStar.UInt64
let main () = C.EXIT_SUCCESS // dummy for compilation
noeq
type llist_cell = {
value: U64.t;
next: ref llist_cell;
}
[@@__reduce__]
let llist_nil
(p: ref llist_cell)
: Tot vprop
= pure (p == null)
... | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Ghost.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": false,
"full_module": "Steel.ST.Loops",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Reference",
"short_module": null
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Steel.ST.Reference.ref LListReverse.llist_cell {Cons? (FStar.Ghost.reveal l)}
-> Steel.ST.Effect.STT (Steel.ST.Reference.ref LListReverse.llist_cell) | Steel.ST.Effect.STT | [] | [] | [
"FStar.Ghost.erased",
"Prims.list",
"FStar.UInt64.t",
"Steel.ST.Reference.ref",
"LListReverse.llist_cell",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Ghost.reveal",
"Steel.ST.Util.return",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.ST.Util.exists_",... | [] | false | true | false | false | false | let pop (#l: Ghost.erased (list U64.t)) (p: ref llist_cell {Cons? l})
: STT (ref llist_cell)
(llist l p)
(fun p' ->
exists_ (fun x ->
((pts_to p full_perm x) `star` (llist (List.Tot.tl l) p'))
`star`
(pure (x.value == List.Tot.hd l)))) =
| rewrite (llist l p) (llist_cons (List.Tot.hd l) (llist (List.Tot.tl l)) p);
let _ = gen_elim () in
let x = read p in
let p' = x.next in
vpattern_rewrite (llist _) p';
return p' | false |
Vale.Bignum.X64.fsti | Vale.Bignum.X64.update_of | val update_of : f': Vale.Bignum.X64.flags_t -> o: Vale.Def.Words_s.nat1 -> Prims.logical | let update_of (f':flags_t) (o:nat1) = flag_of f' == o /\ valid_of f' | {
"file_name": "obj/Vale.Bignum.X64.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 68,
"end_line": 21,
"start_col": 0,
"start_line": 21
} | module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f': Vale.Bignum.X64.flags_t -> o: Vale.Def.Words_s.nat1 -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Vale.Bignum.X64.flags_t",
"Vale.Def.Words_s.nat1",
"Prims.l_and",
"Prims.eq2",
"Vale.Bignum.X64.flag_of",
"Prims.b2t",
"Vale.X64.Decls.valid_of",
"Prims.logical"
] | [] | false | false | false | true | true | let update_of (f': flags_t) (o: nat1) =
| flag_of f' == o /\ valid_of f' | false | |
Vale.Bignum.X64.fsti | Vale.Bignum.X64.maintain_of | val maintain_of : f': Vale.Bignum.X64.flags_t -> f: Vale.Bignum.X64.flags_t -> Prims.logical | let maintain_of (f':flags_t) (f:flags_t) = flag_of f' == flag_of f /\ valid_of f' == valid_of f | {
"file_name": "obj/Vale.Bignum.X64.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 95,
"end_line": 23,
"start_col": 0,
"start_line": 23
} | module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f': Vale.Bignum.X64.flags_t -> f: Vale.Bignum.X64.flags_t -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Vale.Bignum.X64.flags_t",
"Prims.l_and",
"Prims.eq2",
"Vale.Def.Words_s.nat1",
"Vale.Bignum.X64.flag_of",
"Prims.bool",
"Vale.X64.Decls.valid_of",
"Prims.logical"
] | [] | false | false | false | true | true | let maintain_of (f' f: flags_t) =
| flag_of f' == flag_of f /\ valid_of f' == valid_of f | false | |
Vale.Bignum.X64.fsti | Vale.Bignum.X64.maintain_cf | val maintain_cf : f': Vale.Bignum.X64.flags_t -> f: Vale.Bignum.X64.flags_t -> Prims.logical | let maintain_cf (f':flags_t) (f:flags_t) = flag_cf f' == flag_cf f /\ valid_cf f' == valid_cf f | {
"file_name": "obj/Vale.Bignum.X64.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 95,
"end_line": 22,
"start_col": 0,
"start_line": 22
} | module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f': Vale.Bignum.X64.flags_t -> f: Vale.Bignum.X64.flags_t -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Vale.Bignum.X64.flags_t",
"Prims.l_and",
"Prims.eq2",
"Vale.Def.Words_s.nat1",
"Vale.Bignum.X64.flag_cf",
"Prims.bool",
"Vale.X64.Decls.valid_cf",
"Prims.logical"
] | [] | false | false | false | true | true | let maintain_cf (f' f: flags_t) =
| flag_cf f' == flag_cf f /\ valid_cf f' == valid_cf f | false | |
Vale.Bignum.X64.fsti | Vale.Bignum.X64.va_wp_Adcx_64 | val va_wp_Adcx_64
(dst: va_operand_dst_opr64)
(src: va_operand_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Adcx_64
(dst: va_operand_dst_opr64)
(src: va_operand_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Adcx_64 (dst:va_operand_dst_opr64) (src:va_operand_opr64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_dst_opr64 dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ adx_enabled /\
Vale.X64.Decls.valid_cf (va_get_flags va_s0) /\ (forall (va_x_dst:va_value_dst_opr64)... | {
"file_name": "obj/Vale.Bignum.X64.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 69,
"start_col": 0,
"start_line": 60
} | module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
dst: Vale.X64.Decls.va_operand_dst_opr64 ->
src: Vale.X64.Decls.va_operand_opr64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_is_dst_dst_opr64",
"Vale.X64.Decls.va_is_src_opr64",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.Decl... | [] | false | false | false | true | true | let va_wp_Adcx_64
(dst: va_operand_dst_opr64)
(src: va_operand_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_dst_opr64 dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ adx_enabled /\
Vale.X64.Decls.valid_cf (va_get_flags va_s0) /\
(forall (va_x_dst: va_value_dst_opr64) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_dst_opr64 dst va_x_dst va_s0) in
va_get_... | false |
Vale.Bignum.X64.fsti | Vale.Bignum.X64.va_wp_Adox_64 | val va_wp_Adox_64
(dst: va_operand_dst_opr64)
(src: va_operand_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_Adox_64
(dst: va_operand_dst_opr64)
(src: va_operand_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_Adox_64 (dst:va_operand_dst_opr64) (src:va_operand_opr64) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_dst_opr64 dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ adx_enabled /\
Vale.X64.Decls.valid_of (va_get_flags va_s0) /\ (forall (va_x_dst:va_value_dst_opr64)... | {
"file_name": "obj/Vale.Bignum.X64.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 46,
"end_line": 112,
"start_col": 0,
"start_line": 103
} | module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
dst: Vale.X64.Decls.va_operand_dst_opr64 ->
src: Vale.X64.Decls.va_operand_opr64 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_is_dst_dst_opr64",
"Vale.X64.Decls.va_is_src_opr64",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.Decl... | [] | false | false | false | true | true | let va_wp_Adox_64
(dst: va_operand_dst_opr64)
(src: va_operand_opr64)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_is_dst_dst_opr64 dst va_s0 /\ va_is_src_opr64 src va_s0 /\ va_get_ok va_s0 /\ adx_enabled /\
Vale.X64.Decls.valid_of (va_get_flags va_s0) /\
(forall (va_x_dst: va_value_dst_opr64) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_dst_opr64 dst va_x_dst va_s0) in
va_get_... | false |
Vale.Bignum.X64.fsti | Vale.Bignum.X64.va_quick_Adox_64 | val va_quick_Adox_64 (dst: va_operand_dst_opr64) (src: va_operand_opr64)
: (va_quickCode unit (va_code_Adox_64 dst src)) | val va_quick_Adox_64 (dst: va_operand_dst_opr64) (src: va_operand_opr64)
: (va_quickCode unit (va_code_Adox_64 dst src)) | let va_quick_Adox_64 (dst:va_operand_dst_opr64) (src:va_operand_opr64) : (va_quickCode unit
(va_code_Adox_64 dst src)) =
(va_QProc (va_code_Adox_64 dst src) ([va_Mod_flags; va_mod_dst_opr64 dst]) (va_wp_Adox_64 dst
src) (va_wpProof_Adox_64 dst src)) | {
"file_name": "obj/Vale.Bignum.X64.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 124,
"start_col": 0,
"start_line": 121
} | module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | dst: Vale.X64.Decls.va_operand_dst_opr64 -> src: Vale.X64.Decls.va_operand_opr64
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.Bignum.X64.va_code_Adox_64 dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Bignum.X64.va_code_Adox_64",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_dst_opr64",
"Prims.Nil",
"Vale.Bignum.... | [] | false | false | false | false | false | let va_quick_Adox_64 (dst: va_operand_dst_opr64) (src: va_operand_opr64)
: (va_quickCode unit (va_code_Adox_64 dst src)) =
| (va_QProc (va_code_Adox_64 dst src)
([va_Mod_flags; va_mod_dst_opr64 dst])
(va_wp_Adox_64 dst src)
(va_wpProof_Adox_64 dst src)) | false |
Vale.Bignum.X64.fsti | Vale.Bignum.X64.va_quick_Adcx_64 | val va_quick_Adcx_64 (dst: va_operand_dst_opr64) (src: va_operand_opr64)
: (va_quickCode unit (va_code_Adcx_64 dst src)) | val va_quick_Adcx_64 (dst: va_operand_dst_opr64) (src: va_operand_opr64)
: (va_quickCode unit (va_code_Adcx_64 dst src)) | let va_quick_Adcx_64 (dst:va_operand_dst_opr64) (src:va_operand_opr64) : (va_quickCode unit
(va_code_Adcx_64 dst src)) =
(va_QProc (va_code_Adcx_64 dst src) ([va_Mod_flags; va_mod_dst_opr64 dst]) (va_wp_Adcx_64 dst
src) (va_wpProof_Adcx_64 dst src)) | {
"file_name": "obj/Vale.Bignum.X64.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 81,
"start_col": 0,
"start_line": 78
} | module Vale.Bignum.X64
open Vale.Def.Words_s
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | dst: Vale.X64.Decls.va_operand_dst_opr64 -> src: Vale.X64.Decls.va_operand_opr64
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.Bignum.X64.va_code_Adcx_64 dst src) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_dst_opr64",
"Vale.X64.Decls.va_operand_opr64",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.Bignum.X64.va_code_Adcx_64",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_dst_opr64",
"Prims.Nil",
"Vale.Bignum.... | [] | false | false | false | false | false | let va_quick_Adcx_64 (dst: va_operand_dst_opr64) (src: va_operand_opr64)
: (va_quickCode unit (va_code_Adcx_64 dst src)) =
| (va_QProc (va_code_Adcx_64 dst src)
([va_Mod_flags; va_mod_dst_opr64 dst])
(va_wp_Adcx_64 dst src)
(va_wpProof_Adcx_64 dst src)) | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_as_nat5 | val lemma_as_nat5: f:qelem5 ->
Lemma
(requires qelem_fits5 f (1, 1, 1, 1, 1))
(ensures as_nat5 f < pow2 280) | val lemma_as_nat5: f:qelem5 ->
Lemma
(requires qelem_fits5 f (1, 1, 1, 1, 1))
(ensures as_nat5 f < pow2 280) | let lemma_as_nat5 f =
//let (f0, f1, f2, f3, f4) = f in
//assert (as_nat5 f == v f0 + v f1 * pow56 + v f2 * pow112 + v f3 * pow168 + v f4 * pow224);
assert_norm (pow2 56 * pow2 56 = pow2 112);
assert_norm (pow2 56 * pow2 112 = pow2 168);
assert_norm (pow2 56 * pow2 168 = pow2 224);
assert_norm (pow2 56 * po... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 36,
"start_col": 0,
"start_line": 30
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"ful... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: Hacl.Spec.BignumQ.Definitions.qelem5
-> FStar.Pervasives.Lemma (requires Hacl.Spec.BignumQ.Definitions.qelem_fits5 f (1, 1, 1, 1, 1))
(ensures Hacl.Spec.BignumQ.Definitions.as_nat5 f < Prims.pow2 280) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.BignumQ.Definitions.qelem5",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_as_nat5 f =
| assert_norm (pow2 56 * pow2 56 = pow2 112);
assert_norm (pow2 56 * pow2 112 = pow2 168);
assert_norm (pow2 56 * pow2 168 = pow2 224);
assert_norm (pow2 56 * pow2 224 = pow2 280) | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_choose_step | val lemma_choose_step:
bit:uint64{v bit <= 1}
-> x:uint64
-> y:uint64
-> Lemma
(let mask = bit -. u64 1 in
let z = x ^. (mask &. (x ^. y)) in
if v bit = 1 then z == x else z == y) | val lemma_choose_step:
bit:uint64{v bit <= 1}
-> x:uint64
-> y:uint64
-> Lemma
(let mask = bit -. u64 1 in
let z = x ^. (mask &. (x ^. y)) in
if v bit = 1 then z == x else z == y) | let lemma_choose_step bit p1 p2 =
let mask = bit -. u64 1 in
assert (v bit == 0 ==> v mask == pow2 64 - 1);
assert (v bit == 1 ==> v mask == 0);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == 0);
assert (v bit == 0 ==> v dummy == v (p1 ^. p2));
let p1'... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 20,
"end_line": 58,
"start_col": 0,
"start_line": 48
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"ful... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
bit: Lib.IntTypes.uint64{Lib.IntTypes.v bit <= 1} ->
x: Lib.IntTypes.uint64 ->
y: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(let mask = bit -. Lib.IntTypes.u64 1 in
let z = x ^. (mask &. x ^. y) in
(match Lib.IntTypes.v bit = 1 with
| true -> z == x
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.uint64",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.logxor_lemma",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Prims.op_Equality",
"Prims.int",
"Lib.IntTypes.u64",
"Prims.bool",
... | [] | false | false | true | false | false | let lemma_choose_step bit p1 p2 =
| let mask = bit -. u64 1 in
assert (v bit == 0 ==> v mask == pow2 64 - 1);
assert (v bit == 1 ==> v mask == 0);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == 0);
assert (v bit == 0 ==> v dummy == v (p1 ^. p2));
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = ... | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_div248_x5 | val lemma_div248_x5: x5:uint64 ->
Lemma ( pow2 32 * (v x5 % pow2 24) + v x5 / pow2 24 * pow2 56 == v x5 * pow2 32) | val lemma_div248_x5: x5:uint64 ->
Lemma ( pow2 32 * (v x5 % pow2 24) + v x5 / pow2 24 * pow2 56 == v x5 * pow2 32) | let lemma_div248_x5 x5 =
assert_norm (pow2 32 * pow2 24 = pow2 56) | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 165,
"start_col": 0,
"start_line": 164
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x5: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
Prims.pow2 32 * (Lib.IntTypes.v x5 % Prims.pow2 24) +
(Lib.IntTypes.v x5 / Prims.pow2 24) * Prims.pow2 56 ==
Lib.IntTypes.v x5 * Prims.pow2 32) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.uint64",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_div248_x5 x5 =
| assert_norm (pow2 32 * pow2 24 = pow2 56) | false |
Steel.ST.SeqMatch.fst | Steel.ST.SeqMatch.seq_seq_match_upd | val seq_seq_match_upd
(#opened: _)
(#t1 #t2: Type)
(p: (t1 -> t2 -> vprop))
(s1: Seq.seq t1)
(s2: Seq.seq t2)
(i j: nat)
(k: nat{i <= j /\ j < k})
(x1: t1)
(x2: t2)
: STGhostT (squash (j < Seq.length s1 /\ j < Seq.length s2))
opened
((seq_seq_match p... | val seq_seq_match_upd
(#opened: _)
(#t1 #t2: Type)
(p: (t1 -> t2 -> vprop))
(s1: Seq.seq t1)
(s2: Seq.seq t2)
(i j: nat)
(k: nat{i <= j /\ j < k})
(x1: t1)
(x2: t2)
: STGhostT (squash (j < Seq.length s1 /\ j < Seq.length s2))
opened
((seq_seq_match p... | let seq_seq_match_upd
(#opened: _)
(#t1 #t2: Type)
(p: t1 -> t2 -> vprop)
(s1: Seq.seq t1)
(s2: Seq.seq t2)
(i j: nat)
(k: nat {
i <= j /\ j < k
})
(x1: t1)
(x2: t2)
: STGhostT (squash (j < Seq.length s1 /\ j < Seq.length s2)) opened
(seq_seq_match p s1 s2 i k `star` p x1 x2)
(fun _ ->
... | {
"file_name": "lib/steel/Steel.ST.SeqMatch.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 5,
"end_line": 727,
"start_col": 0,
"start_line": 688
} | module Steel.ST.SeqMatch
include Steel.ST.OnRange
open Steel.ST.GenElim
module Seq = FStar.Seq
module SZ = FStar.SizeT
(* `seq_list_match` describes how to match a sequence of low-level
values (the low-level contents of an array) with a list of high-level
values. `seq_list_match` is carefully designed to be usable wi... | {
"checked_file": "/",
"dependencies": [
"Steel.ST.OnRange.fsti.checked",
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_fil... | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "SZ"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Steel.ST.GenElim",
"short_module": null
},
{
"abbrev": false,
"full_module": "Stee... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: (_: t1 -> _: t2 -> Steel.Effect.Common.vprop) ->
s1: FStar.Seq.Base.seq t1 ->
s2: FStar.Seq.Base.seq t2 ->
i: Prims.nat ->
j: Prims.nat ->
k: Prims.nat{i <= j /\ j < k} ->
x1: t1 ->
x2: t2
-> Steel.ST.Effect.Ghost.STGhostT
(Prims.squash (j < FStar.Seq.Base.length s1 /\ j < FSta... | Steel.ST.Effect.Ghost.STGhostT | [] | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.squash",
"FStar.Seq.Base.length",
"Prims.unit",
"Steel.ST.OnRange.on_range_put",
"Steel.ST.SeqMatch.seq_seq_match_item",
... | [] | false | true | true | false | false | let seq_seq_match_upd
(#opened: _)
(#t1 #t2: Type)
(p: (t1 -> t2 -> vprop))
(s1: Seq.seq t1)
(s2: Seq.seq t2)
(i j: nat)
(k: nat{i <= j /\ j < k})
(x1: t1)
(x2: t2)
: STGhostT (squash (j < Seq.length s1 /\ j < Seq.length s2))
opened
((seq_seq_match p... | seq_seq_match_length p s1 s2 i k;
on_range_get (seq_seq_match_item p s1 s2) i j (j + 1) k;
let res:squash (j < Seq.length s1 /\ j < Seq.length s2) = () in
drop (seq_seq_match_item p s1 s2 j);
rewrite (p x1 x2) (seq_seq_match_item p (Seq.upd s1 j x1) (Seq.upd s2 j x2) j);
seq_seq_match_weaken p p (fun _ _ -> noop ()) s1... | false |
Steel.ST.C.Types.Base.fsti | Steel.ST.C.Types.Base.void_ptr_of_ref | val void_ptr_of_ref (#t: Type) (#opened: _) (#td: typedef t) (#v: Ghost.erased t) (x: ref td)
: STAtomicBase void_ptr
false
opened
Unobservable
(pts_to x v)
(fun _ -> pts_to x v)
True
(fun y -> y == ghost_void_ptr_of_ptr_gen x) | val void_ptr_of_ref (#t: Type) (#opened: _) (#td: typedef t) (#v: Ghost.erased t) (x: ref td)
: STAtomicBase void_ptr
false
opened
Unobservable
(pts_to x v)
(fun _ -> pts_to x v)
True
(fun y -> y == ghost_void_ptr_of_ptr_gen x) | let void_ptr_of_ref (#t: Type) (#opened: _) (#td: typedef t) (#v: Ghost.erased t) (x: ref td) : STAtomicBase void_ptr false opened Unobservable
(pts_to x v)
(fun _ -> pts_to x v)
True
(fun y -> y == ghost_void_ptr_of_ptr_gen x)
= rewrite (pts_to x v) (pts_to_or_null x v);
let res = void_ptr_of_ptr x in
rewr... | {
"file_name": "lib/steel/c/Steel.ST.C.Types.Base.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 12,
"end_line": 166,
"start_col": 0,
"start_line": 158
} | module Steel.ST.C.Types.Base
open Steel.ST.Util
module P = Steel.FractionalPermission
/// Helper to compose two permissions into one
val prod_perm (p1 p2: P.perm) : Pure P.perm
(requires True)
(ensures (fun p ->
((p1 `P.lesser_equal_perm` P.full_perm /\ p2 `P.lesser_equal_perm` P.full_perm) ==>
p `P.lesse... | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": ... | [
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types",
"short_module": null
},
{
"abbrev": false,
"f... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Steel.ST.C.Types.Base.ref td
-> Steel.ST.Effect.Atomic.STAtomicBase Steel.ST.C.Types.Base.void_ptr | Steel.ST.Effect.Atomic.STAtomicBase | [] | [] | [
"Steel.Memory.inames",
"Steel.ST.C.Types.Base.typedef",
"FStar.Ghost.erased",
"Steel.ST.C.Types.Base.ref",
"Steel.ST.Util.return",
"Steel.ST.C.Types.Base.void_ptr",
"Steel.ST.C.Types.Base.pts_to",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.ST.Util.rewrite",
"Steel.ST.C.Types.Base.pts_to_o... | [] | false | true | false | false | false | let void_ptr_of_ref (#t: Type) (#opened: _) (#td: typedef t) (#v: Ghost.erased t) (x: ref td)
: STAtomicBase void_ptr
false
opened
Unobservable
(pts_to x v)
(fun _ -> pts_to x v)
True
(fun y -> y == ghost_void_ptr_of_ptr_gen x) =
| rewrite (pts_to x v) (pts_to_or_null x v);
let res = void_ptr_of_ptr x in
rewrite (pts_to_or_null x v) (pts_to x v);
return res | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_add_modq5 | val lemma_add_modq5:
x:qelem5
-> y:qelem5
-> t:qelem5 ->
Lemma
(requires
qelem_fits5 x (1, 1, 1, 1, 1) /\
qelem_fits5 y (1, 1, 1, 1, 1) /\
qelem_fits5 t (1, 1, 1, 1, 1) /\
as_nat5 x < S.q /\ as_nat5 y < S.q /\
as_nat5 t == as_nat5 x + as_nat5 y)
(ensures
(let res = if as_nat5 t >= S... | val lemma_add_modq5:
x:qelem5
-> y:qelem5
-> t:qelem5 ->
Lemma
(requires
qelem_fits5 x (1, 1, 1, 1, 1) /\
qelem_fits5 y (1, 1, 1, 1, 1) /\
qelem_fits5 t (1, 1, 1, 1, 1) /\
as_nat5 x < S.q /\ as_nat5 y < S.q /\
as_nat5 t == as_nat5 x + as_nat5 y)
(ensures
(let res = if as_nat5 t >= S... | let lemma_add_modq5 x y t =
assert (as_nat5 t == as_nat5 x + as_nat5 y);
let res = if as_nat5 t >= S.q then as_nat5 t - S.q else as_nat5 t in
assert (res < S.q);
if as_nat5 t >= S.q then (
FStar.Math.Lemmas.sub_div_mod_1 (as_nat5 t) S.q;
assert (res % S.q == as_nat5 t % S.q))
else
assert (res % S... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 306,
"start_col": 0,
"start_line": 296
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
x: Hacl.Spec.BignumQ.Definitions.qelem5 ->
y: Hacl.Spec.BignumQ.Definitions.qelem5 ->
t: Hacl.Spec.BignumQ.Definitions.qelem5
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.BignumQ.Definitions.qelem_fits5 x (1, 1, 1, 1, 1) /\
Hacl.Spec.BignumQ.Definitions.qelem_fits5 y (1, 1, 1, 1, 1... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.BignumQ.Definitions.qelem5",
"FStar.Math.Lemmas.small_mod",
"Spec.Ed25519.q",
"Prims.unit",
"Prims.op_GreaterThanOrEqual",
"Hacl.Spec.BignumQ.Definitions.as_nat5",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Math.Lemmas.sub_div_mod_1",
"Prims.bool",
"Prim... | [] | false | false | true | false | false | let lemma_add_modq5 x y t =
| assert (as_nat5 t == as_nat5 x + as_nat5 y);
let res = if as_nat5 t >= S.q then as_nat5 t - S.q else as_nat5 t in
assert (res < S.q);
if as_nat5 t >= S.q
then
(FStar.Math.Lemmas.sub_div_mod_1 (as_nat5 t) S.q;
assert (res % S.q == as_nat5 t % S.q))
else assert (res % S.q == as_nat5 t % S.q);
FStar.Math.Lemmas.smal... | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_div248_x6 | val lemma_div248_x6: x6:uint64 ->
Lemma (pow2 32 * (v x6 % pow2 24) * pow2 56 + v x6 / pow2 24 * pow2 112 == v x6 * pow2 88) | val lemma_div248_x6: x6:uint64 ->
Lemma (pow2 32 * (v x6 % pow2 24) * pow2 56 + v x6 / pow2 24 * pow2 112 == v x6 * pow2 88) | let lemma_div248_x6 x6 =
calc (==) {
pow2 32 * (v x6 % pow2 24) * pow2 56 + v x6 / pow2 24 * pow2 112;
(==) { _ by (Tactics.norm [delta_only [`%pow2]; primops]; int_semiring ()) }
((v x6 / pow2 24) * pow2 24 + v x6 % pow2 24) * pow2 88;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v x6) (po... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 176,
"start_col": 0,
"start_line": 169
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x6: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(Prims.pow2 32 * (Lib.IntTypes.v x6 % Prims.pow2 24)) * Prims.pow2 56 +
(Lib.IntTypes.v x6 / Prims.pow2 24) * Prims.pow2 112 ==
Lib.IntTypes.v x6 * Prims.pow2 88) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.uint64",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Modulus",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_Division",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"P... | [] | false | false | true | false | false | let lemma_div248_x6 x6 =
| calc ( == ) {
(pow2 32 * (v x6 % pow2 24)) * pow2 56 + (v x6 / pow2 24) * pow2 112;
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ ->
(Tactics.norm [delta_only [`%pow2]; primops];
int_semiring ())) }
((v x6 / pow2 24) * pow2 24 + v x6 % pow2 24) * pow2 88;
( == ) { FStar.Math.Lemmas.eucl... | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_wide_as_nat_pow528 | val lemma_wide_as_nat_pow528: x:qelem_wide5 ->
Lemma
(requires
qelem_wide_fits5 x (1, 1, 1, 1, 1, 1, 1, 1, 1, 1) /\
wide_as_nat5 x < pow2 528)
(ensures
(let (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) = x in
v x9 < pow2 40)) | val lemma_wide_as_nat_pow528: x:qelem_wide5 ->
Lemma
(requires
qelem_wide_fits5 x (1, 1, 1, 1, 1, 1, 1, 1, 1, 1) /\
wide_as_nat5 x < pow2 528)
(ensures
(let (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) = x in
v x9 < pow2 40)) | let lemma_wide_as_nat_pow528 x =
let (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) = x in
assert_norm (pow2 504 * pow2 24 = pow2 528);
FStar.Math.Lemmas.pow2_minus 528 504;
assert (v x9 < pow2 24);
assert_norm (pow2 24 < pow2 40) | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 33,
"end_line": 323,
"start_col": 0,
"start_line": 318
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Hacl.Spec.BignumQ.Definitions.qelem_wide5
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.BignumQ.Definitions.qelem_wide_fits5 x (1, 1, 1, 1, 1, 1, 1, 1, 1, 1) /\
Hacl.Spec.BignumQ.Definitions.wide_as_nat5 x < Prims.pow2 528)
(ensures
(let _ = x in
(let FStar.Pervasives.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.BignumQ.Definitions.qelem_wide5",
"Lib.IntTypes.uint64",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.unit",
"Prims._assert",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Math.Lemmas.pow2_minus",
"Prims.op_Equality",
... | [] | false | false | true | false | false | let lemma_wide_as_nat_pow528 x =
| let x0, x1, x2, x3, x4, x5, x6, x7, x8, x9 = x in
assert_norm (pow2 504 * pow2 24 = pow2 528);
FStar.Math.Lemmas.pow2_minus 528 504;
assert (v x9 < pow2 24);
assert_norm (pow2 24 < pow2 40) | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_as_nat_pow264 | val lemma_as_nat_pow264: x:qelem5 ->
Lemma
(requires
(let (x0, x1, x2, x3, x4) = x in
qelem_fits5 x (1, 1, 1, 1, 1) /\
v x4 < pow2 40))
(ensures as_nat5 x < pow2 264) | val lemma_as_nat_pow264: x:qelem5 ->
Lemma
(requires
(let (x0, x1, x2, x3, x4) = x in
qelem_fits5 x (1, 1, 1, 1, 1) /\
v x4 < pow2 40))
(ensures as_nat5 x < pow2 264) | let lemma_as_nat_pow264 x =
let (x0, x1, x2, x3, x4) = x in
assert_norm (pow2 40 * pow2 224 = pow2 264) | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 513,
"start_col": 0,
"start_line": 511
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Hacl.Spec.BignumQ.Definitions.qelem5
-> FStar.Pervasives.Lemma
(requires
(let _ = x in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ _ _ _ _ x4 = _ in
Hacl.Spec.BignumQ.Definitions.qelem_fits5 x (1, 1, 1, 1, 1) /\
Lib.IntTypes.v x4 < Prims.pow2 40)
<... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.BignumQ.Definitions.qelem5",
"Lib.IntTypes.uint64",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.unit"
] | [] | false | false | true | false | false | let lemma_as_nat_pow264 x =
| let x0, x1, x2, x3, x4 = x in
assert_norm (pow2 40 * pow2 224 = pow2 264) | false |
SfBasic.fst | SfBasic.next_weekday | val next_weekday : day -> Tot day | val next_weekday : day -> Tot day | let next_weekday d =
match d with
| Monday -> Tuesday
| Tuesday -> Wednesday
| Wednesday -> Thursday
| Thursday -> Friday
| Friday -> Monday
| Saturday -> Monday
| Sunday -> Monday | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 41,
"start_col": 0,
"start_line": 33
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | d: SfBasic.day -> SfBasic.day | Prims.Tot | [
"total"
] | [] | [
"SfBasic.day",
"SfBasic.Tuesday",
"SfBasic.Wednesday",
"SfBasic.Thursday",
"SfBasic.Friday",
"SfBasic.Monday"
] | [] | false | false | false | true | false | let next_weekday d =
| match d with
| Monday -> Tuesday
| Tuesday -> Wednesday
| Wednesday -> Thursday
| Thursday -> Friday
| Friday -> Monday
| Saturday -> Monday
| Sunday -> Monday | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_wide_as_nat_pow512 | val lemma_wide_as_nat_pow512: x:qelem_wide5 ->
Lemma
(requires
qelem_wide_fits5 x (1, 1, 1, 1, 1, 1, 1, 1, 1, 1) /\
wide_as_nat5 x < pow2 512)
(ensures
(let (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) = x in
v x9 < pow2 24)) | val lemma_wide_as_nat_pow512: x:qelem_wide5 ->
Lemma
(requires
qelem_wide_fits5 x (1, 1, 1, 1, 1, 1, 1, 1, 1, 1) /\
wide_as_nat5 x < pow2 512)
(ensures
(let (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) = x in
v x9 < pow2 24)) | let lemma_wide_as_nat_pow512 x =
let (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) = x in
assert_norm (pow2 504 * pow2 8 = pow2 512);
FStar.Math.Lemmas.pow2_minus 512 504;
assert (v x9 < pow2 8);
assert_norm (pow2 8 < pow2 24) | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 229,
"start_col": 0,
"start_line": 224
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Hacl.Spec.BignumQ.Definitions.qelem_wide5
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.BignumQ.Definitions.qelem_wide_fits5 x (1, 1, 1, 1, 1, 1, 1, 1, 1, 1) /\
Hacl.Spec.BignumQ.Definitions.wide_as_nat5 x < Prims.pow2 512)
(ensures
(let _ = x in
(let FStar.Pervasives.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.BignumQ.Definitions.qelem_wide5",
"Lib.IntTypes.uint64",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.unit",
"Prims._assert",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Math.Lemmas.pow2_minus",
"Prims.op_Equality",
... | [] | false | false | true | false | false | let lemma_wide_as_nat_pow512 x =
| let x0, x1, x2, x3, x4, x5, x6, x7, x8, x9 = x in
assert_norm (pow2 504 * pow2 8 = pow2 512);
FStar.Math.Lemmas.pow2_minus 512 504;
assert (v x9 < pow2 8);
assert_norm (pow2 8 < pow2 24) | false |
SfBasic.fst | SfBasic.orb | val orb : mbool -> mbool -> Tot mbool | val orb : mbool -> mbool -> Tot mbool | let orb b1 b2 =
match b1 with
| MTrue -> MTrue
| MFalse -> b2 | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 16,
"end_line": 73,
"start_col": 0,
"start_line": 70
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b1: SfBasic.mbool -> b2: SfBasic.mbool -> SfBasic.mbool | Prims.Tot | [
"total"
] | [] | [
"SfBasic.mbool",
"SfBasic.MTrue"
] | [] | false | false | false | true | false | let orb b1 b2 =
| match b1 with
| MTrue -> MTrue
| MFalse -> b2 | false |
SfBasic.fst | SfBasic.negb | val negb : mbool -> Tot mbool | val negb : mbool -> Tot mbool | let negb b =
match b with
| MTrue -> MFalse
| MFalse -> MTrue | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 61,
"start_col": 0,
"start_line": 58
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b: SfBasic.mbool -> SfBasic.mbool | Prims.Tot | [
"total"
] | [] | [
"SfBasic.mbool",
"SfBasic.MFalse",
"SfBasic.MTrue"
] | [] | false | false | false | true | false | let negb b =
| match b with
| MTrue -> MFalse
| MFalse -> MTrue | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_sub_mod_264_aux | val lemma_sub_mod_264_aux:
x0:nat -> x1:nat -> x2:nat -> x3:nat -> x4:nat
-> y0:nat -> y1:nat -> y2:nat -> y3:nat -> y4:nat
-> c1:nat -> c2:nat -> c3:nat -> c4:nat -> c5:nat ->
Lemma (
x0 - y0 + c1 * pow56 +
(x1 - y1 - c1 + c2 * pow56) * pow56 +
(x2 - y2 - c2 + c3 * pow56) * pow112 +
(x3 - y3 ... | val lemma_sub_mod_264_aux:
x0:nat -> x1:nat -> x2:nat -> x3:nat -> x4:nat
-> y0:nat -> y1:nat -> y2:nat -> y3:nat -> y4:nat
-> c1:nat -> c2:nat -> c3:nat -> c4:nat -> c5:nat ->
Lemma (
x0 - y0 + c1 * pow56 +
(x1 - y1 - c1 + c2 * pow56) * pow56 +
(x2 - y2 - c2 + c3 * pow56) * pow112 +
(x3 - y3 ... | let lemma_sub_mod_264_aux x0 x1 x2 x3 x4 y0 y1 y2 y3 y4 b0 b1 b2 b3 b4 =
assert_norm (pow2 56 * pow2 56 = pow2 112);
assert_norm (pow2 56 * pow2 112 = pow2 168);
assert_norm (pow2 56 * pow2 168 = pow2 224);
assert_norm (pow2 40 * pow2 224 = pow2 264) | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 581,
"start_col": 0,
"start_line": 577
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
x0: Prims.nat ->
x1: Prims.nat ->
x2: Prims.nat ->
x3: Prims.nat ->
x4: Prims.nat ->
y0: Prims.nat ->
y1: Prims.nat ->
y2: Prims.nat ->
y3: Prims.nat ->
y4: Prims.nat ->
c1: Prims.nat ->
c2: Prims.nat ->
c3: Prims.nat ->
c4: Prims.nat ->
c5: Prims.nat
-> FS... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_sub_mod_264_aux x0 x1 x2 x3 x4 y0 y1 y2 y3 y4 b0 b1 b2 b3 b4 =
| assert_norm (pow2 56 * pow2 56 = pow2 112);
assert_norm (pow2 56 * pow2 112 = pow2 168);
assert_norm (pow2 56 * pow2 168 = pow2 224);
assert_norm (pow2 40 * pow2 224 = pow2 264) | false |
SfBasic.fst | SfBasic.andb | val andb : mbool -> mbool -> Tot mbool | val andb : mbool -> mbool -> Tot mbool | let andb b1 b2 =
match b1 with
| MTrue -> b2
| MFalse -> MFalse | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 67,
"start_col": 0,
"start_line": 64
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | b1: SfBasic.mbool -> b2: SfBasic.mbool -> SfBasic.mbool | Prims.Tot | [
"total"
] | [] | [
"SfBasic.mbool",
"SfBasic.MFalse"
] | [] | false | false | false | true | false | let andb b1 b2 =
| match b1 with
| MTrue -> b2
| MFalse -> MFalse | false |
SfBasic.fst | SfBasic.oddb | val oddb : nat -> Tot mbool | val oddb : nat -> Tot mbool | let oddb n = negb (evenb n) | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 118,
"start_col": 0,
"start_line": 118
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: SfBasic.nat -> SfBasic.mbool | Prims.Tot | [
"total"
] | [] | [
"SfBasic.nat",
"SfBasic.negb",
"SfBasic.evenb",
"SfBasic.mbool"
] | [] | false | false | false | true | false | let oddb n =
| negb (evenb n) | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_div264_x5 | val lemma_div264_x5: x5:uint64 ->
Lemma (pow2 16 * (v x5 % pow2 40) + v x5 / pow2 40 * pow2 56 == v x5 * pow2 16) | val lemma_div264_x5: x5:uint64 ->
Lemma (pow2 16 * (v x5 % pow2 40) + v x5 / pow2 40 * pow2 56 == v x5 * pow2 16) | let lemma_div264_x5 x5 =
assert_norm (0 < pow2 24);
calc (==) {
pow2 16 * (v x5 % pow2 40) + v x5 / pow2 40 * pow2 56;
(==) { _ by (Tactics.norm [delta_only [`%pow2]; primops]; int_semiring ()) }
((v x5 / pow2 40) * pow2 40 + v x5 % pow2 40) * pow2 16;
(==) { FStar.Math.Lemmas.euclidean_division_def... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 369,
"start_col": 0,
"start_line": 361
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x5: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
Prims.pow2 16 * (Lib.IntTypes.v x5 % Prims.pow2 40) +
(Lib.IntTypes.v x5 / Prims.pow2 40) * Prims.pow2 56 ==
Lib.IntTypes.v x5 * Prims.pow2 16) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.uint64",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Modulus",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_Division",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"P... | [] | false | false | true | false | false | let lemma_div264_x5 x5 =
| assert_norm (0 < pow2 24);
calc ( == ) {
pow2 16 * (v x5 % pow2 40) + (v x5 / pow2 40) * pow2 56;
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ ->
(Tactics.norm [delta_only [`%pow2]; primops];
int_semiring ())) }
((v x5 / pow2 40) * pow2 40 + v x5 % pow2 40) * pow2 16;
( == ) { FStar.Ma... | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_as_nat_pow264_x4 | val lemma_as_nat_pow264_x4: x:qelem5 ->
Lemma
(requires
qelem_fits5 x (1, 1, 1, 1, 1) /\
as_nat5 x < pow2 264)
(ensures
(let (x0, x1, x2, x3, x4) = x in
v x4 < pow2 40)) | val lemma_as_nat_pow264_x4: x:qelem5 ->
Lemma
(requires
qelem_fits5 x (1, 1, 1, 1, 1) /\
as_nat5 x < pow2 264)
(ensures
(let (x0, x1, x2, x3, x4) = x in
v x4 < pow2 40)) | let lemma_as_nat_pow264_x4 x =
let (x0, x1, x2, x3, x4) = x in
assert_norm (pow2 40 * pow2 224 = pow2 264) | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 560,
"start_col": 0,
"start_line": 558
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Hacl.Spec.BignumQ.Definitions.qelem5
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.BignumQ.Definitions.qelem_fits5 x (1, 1, 1, 1, 1) /\
Hacl.Spec.BignumQ.Definitions.as_nat5 x < Prims.pow2 264)
(ensures
(let _ = x in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.BignumQ.Definitions.qelem5",
"Lib.IntTypes.uint64",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.unit"
] | [] | false | false | true | false | false | let lemma_as_nat_pow264_x4 x =
| let x0, x1, x2, x3, x4 = x in
assert_norm (pow2 40 * pow2 224 = pow2 264) | false |
SfBasic.fst | SfBasic.pred | val pred : nat -> Tot nat | val pred : nat -> Tot nat | let pred n =
match n with
| O -> O
| S n' -> n' | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 16,
"end_line": 101,
"start_col": 0,
"start_line": 98
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: SfBasic.nat -> SfBasic.nat | Prims.Tot | [
"total"
] | [] | [
"SfBasic.nat",
"SfBasic.O"
] | [] | false | false | false | true | false | let pred n =
| match n with
| O -> O
| S n' -> n' | false |
SfBasic.fst | SfBasic.minustwo | val minustwo : nat -> Tot nat | val minustwo : nat -> Tot nat | let minustwo n =
match n with
| O -> O
| S O -> O
| S (S n') -> n' | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 108,
"start_col": 0,
"start_line": 104
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: SfBasic.nat -> SfBasic.nat | Prims.Tot | [
"total"
] | [] | [
"SfBasic.nat",
"SfBasic.O"
] | [] | false | false | false | true | false | let minustwo n =
| match n with
| O -> O
| S O -> O
| S (S n') -> n' | false |
SfBasic.fst | SfBasic.evenb | val evenb : nat -> Tot mbool | val evenb : nat -> Tot mbool | let rec evenb n =
match n with
| O -> MTrue
| S O -> MFalse
| S (S n') -> evenb n' | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 24,
"end_line": 115,
"start_col": 0,
"start_line": 111
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: SfBasic.nat -> SfBasic.mbool | Prims.Tot | [
"total"
] | [] | [
"SfBasic.nat",
"SfBasic.MTrue",
"SfBasic.MFalse",
"SfBasic.evenb",
"SfBasic.mbool"
] | [
"recursion"
] | false | false | false | true | false | let rec evenb n =
| match n with
| O -> MTrue
| S O -> MFalse
| S (S n') -> evenb n' | false |
SfBasic.fst | SfBasic.plus | val plus : nat -> nat -> Tot nat | val plus : nat -> nat -> Tot nat | let rec plus n m =
match n with
| O -> m
| S n' -> S (plus n' m) | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 132,
"start_col": 0,
"start_line": 129
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: SfBasic.nat -> m: SfBasic.nat -> SfBasic.nat | Prims.Tot | [
"total"
] | [] | [
"SfBasic.nat",
"SfBasic.S",
"SfBasic.plus"
] | [
"recursion"
] | false | false | false | true | false | let rec plus n m =
| match n with
| O -> m
| S n' -> S (plus n' m) | false |
SfBasic.fst | SfBasic.beq_nat | val beq_nat : nat -> nat -> Tot mbool | val beq_nat : nat -> nat -> Tot mbool | let rec beq_nat n m =
match n, m with
| O , O -> MTrue
| S n', S m' -> beq_nat n' m'
| _ , _ -> MFalse | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 24,
"end_line": 157,
"start_col": 0,
"start_line": 153
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: SfBasic.nat -> m: SfBasic.nat -> SfBasic.mbool | Prims.Tot | [
"total"
] | [] | [
"SfBasic.nat",
"FStar.Pervasives.Native.Mktuple2",
"SfBasic.MTrue",
"SfBasic.beq_nat",
"SfBasic.MFalse",
"SfBasic.mbool"
] | [
"recursion"
] | false | false | false | true | false | let rec beq_nat n m =
| match n, m with
| O, O -> MTrue
| S n', S m' -> beq_nat n' m'
| _, _ -> MFalse | false |
SfBasic.fst | SfBasic.minus | val minus : nat -> nat -> Tot nat | val minus : nat -> nat -> Tot nat | let rec minus (n : nat) (m : nat) : nat =
match n, m with
| O , _ -> O
| S _ , O -> n
| S n', S m' -> minus n' m' | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 150,
"start_col": 0,
"start_line": 146
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: SfBasic.nat -> m: SfBasic.nat -> SfBasic.nat | Prims.Tot | [
"total"
] | [] | [
"SfBasic.nat",
"FStar.Pervasives.Native.Mktuple2",
"SfBasic.O",
"SfBasic.minus"
] | [
"recursion"
] | false | false | false | true | false | let rec minus (n m: nat) : nat =
| match n, m with
| O, _ -> O
| S _, O -> n
| S n', S m' -> minus n' m' | false |
SfBasic.fst | SfBasic.mult | val mult : nat -> nat -> Tot nat | val mult : nat -> nat -> Tot nat | let rec mult n m =
match n with
| O -> O
| S n' -> plus m (mult n' m) | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 138,
"start_col": 0,
"start_line": 135
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: SfBasic.nat -> m: SfBasic.nat -> SfBasic.nat | Prims.Tot | [
"total"
] | [] | [
"SfBasic.nat",
"SfBasic.O",
"SfBasic.plus",
"SfBasic.mult"
] | [
"recursion"
] | false | false | false | true | false | let rec mult n m =
| match n with
| O -> O
| S n' -> plus m (mult n' m) | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_sub_mod_264 | val lemma_sub_mod_264:
x:qelem5
-> y:qelem5
-> t:qelem5
-> c5:uint64 ->
Lemma
(requires
qelem_fits5 x (1, 1, 1, 1, 1) /\
qelem_fits5 y (1, 1, 1, 1, 1) /\
qelem_fits5 t (1, 1, 1, 1, 1) /\
as_nat5 x < pow2 264 /\
as_nat5 y < pow2 264 /\
as_nat5 t == as_nat5 x - as_nat5 y + v c5 * pow... | val lemma_sub_mod_264:
x:qelem5
-> y:qelem5
-> t:qelem5
-> c5:uint64 ->
Lemma
(requires
qelem_fits5 x (1, 1, 1, 1, 1) /\
qelem_fits5 y (1, 1, 1, 1, 1) /\
qelem_fits5 t (1, 1, 1, 1, 1) /\
as_nat5 x < pow2 264 /\
as_nat5 y < pow2 264 /\
as_nat5 t == as_nat5 x - as_nat5 y + v c5 * pow... | let lemma_sub_mod_264 x y t c5 =
assert (if v c5 = 0 then as_nat5 x >= as_nat5 y else as_nat5 x < as_nat5 y);
assert (as_nat5 t == as_nat5 x - as_nat5 y + v c5 * pow2 264);
if as_nat5 x >= as_nat5 y then
assert (v c5 == 0 /\ as_nat5 t == as_nat5 x - as_nat5 y)
else
assert (v c5 == 1 /\ as_nat5 t == as_n... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 71,
"end_line": 610,
"start_col": 0,
"start_line": 604
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
x: Hacl.Spec.BignumQ.Definitions.qelem5 ->
y: Hacl.Spec.BignumQ.Definitions.qelem5 ->
t: Hacl.Spec.BignumQ.Definitions.qelem5 ->
c5: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.BignumQ.Definitions.qelem_fits5 x (1, 1, 1, 1, 1) /\
Hacl.Spec.BignumQ.Definitio... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.BignumQ.Definitions.qelem5",
"Lib.IntTypes.uint64",
"Prims.op_GreaterThanOrEqual",
"Hacl.Spec.BignumQ.Definitions.as_nat5",
"Prims._assert",
"Prims.l_and",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_Subtraction",
"Prims.bool",
"... | [] | false | false | true | false | false | let lemma_sub_mod_264 x y t c5 =
| assert (if v c5 = 0 then as_nat5 x >= as_nat5 y else as_nat5 x < as_nat5 y);
assert (as_nat5 t == as_nat5 x - as_nat5 y + v c5 * pow2 264);
if as_nat5 x >= as_nat5 y
then assert (v c5 == 0 /\ as_nat5 t == as_nat5 x - as_nat5 y)
else assert (v c5 == 1 /\ as_nat5 t == as_nat5 x - as_nat5 y + pow2 264) | false |
SfBasic.fst | SfBasic.ble_nat | val ble_nat : nat -> nat -> Tot mbool | val ble_nat : nat -> nat -> Tot mbool | let rec ble_nat n m =
match n, m with
| O , _ -> MTrue
| S n', O -> MFalse
| S n', S m' -> ble_nat n' m' | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 164,
"start_col": 0,
"start_line": 160
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: SfBasic.nat -> m: SfBasic.nat -> SfBasic.mbool | Prims.Tot | [
"total"
] | [] | [
"SfBasic.nat",
"FStar.Pervasives.Native.Mktuple2",
"SfBasic.MTrue",
"SfBasic.MFalse",
"SfBasic.ble_nat",
"SfBasic.mbool"
] | [
"recursion"
] | false | false | false | true | false | let rec ble_nat n m =
| match n, m with
| O, _ -> MTrue
| S n', O -> MFalse
| S n', S m' -> ble_nat n' m' | false |
SfBasic.fst | SfBasic.plus_0_r | val plus_0_r : n : nat -> Lemma
(ensures (plus n O = n)) | val plus_0_r : n : nat -> Lemma
(ensures (plus n O = n)) | let rec plus_0_r n =
match n with
| O -> ()
| S n' -> plus_0_r n' | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 210,
"start_col": 0,
"start_line": 207
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: SfBasic.nat -> FStar.Pervasives.Lemma (ensures SfBasic.plus n SfBasic.O = n) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"SfBasic.nat",
"SfBasic.plus_0_r",
"Prims.unit"
] | [
"recursion"
] | false | false | true | false | false | let rec plus_0_r n =
| match n with
| O -> ()
| S n' -> plus_0_r n' | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_subm_conditional | val lemma_subm_conditional:
x0:nat -> x1:nat -> x2:nat -> x3:nat -> x4:nat
-> y0:nat -> y1:nat -> y2:nat -> y3:nat -> y4:nat
-> b0:nat -> b1:nat -> b2:nat -> b3:nat -> b4:nat ->
Lemma (
x0 - y0 + b0 * pow2 56 +
(x1 - y1 - b0 + b1 * pow2 56) * pow2 56 +
(x2 - y2 - b1 + b2 * pow2 56) * pow2 112 +
... | val lemma_subm_conditional:
x0:nat -> x1:nat -> x2:nat -> x3:nat -> x4:nat
-> y0:nat -> y1:nat -> y2:nat -> y3:nat -> y4:nat
-> b0:nat -> b1:nat -> b2:nat -> b3:nat -> b4:nat ->
Lemma (
x0 - y0 + b0 * pow2 56 +
(x1 - y1 - b0 + b1 * pow2 56) * pow2 56 +
(x2 - y2 - b1 + b2 * pow2 56) * pow2 112 +
... | let lemma_subm_conditional x0 x1 x2 x3 x4 y0 y1 y2 y3 y4 b0 b1 b2 b3 b4 =
assert_norm (pow2 56 * pow2 56 = pow2 112);
assert_norm (pow2 56 * pow2 112 = pow2 168);
assert_norm (pow2 56 * pow2 168 = pow2 224);
assert_norm (pow2 56 * pow2 224 = pow2 280);
assert (
x0 - y0 + b0 * pow2 56 +
(x1 - y1 - b0 +... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 88,
"start_col": 0,
"start_line": 74
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"ful... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
x0: Prims.nat ->
x1: Prims.nat ->
x2: Prims.nat ->
x3: Prims.nat ->
x4: Prims.nat ->
y0: Prims.nat ->
y1: Prims.nat ->
y2: Prims.nat ->
y3: Prims.nat ->
y4: Prims.nat ->
b0: Prims.nat ->
b1: Prims.nat ->
b2: Prims.nat ->
b3: Prims.nat ->
b4: Prims.nat
-> FS... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"Prims.op_Subtraction",
"FStar.Mul.op_Star",
"Prims.pow2",
"FStar.Tactics.CanonCommSemiring.int_semiring",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality"
] | [] | false | false | true | false | false | let lemma_subm_conditional x0 x1 x2 x3 x4 y0 y1 y2 y3 y4 b0 b1 b2 b3 b4 =
| assert_norm (pow2 56 * pow2 56 = pow2 112);
assert_norm (pow2 56 * pow2 112 = pow2 168);
assert_norm (pow2 56 * pow2 168 = pow2 224);
assert_norm (pow2 56 * pow2 224 = pow2 280);
FStar.Tactics.Effect.assert_by_tactic (x0 - y0 + b0 * pow2 56 +
(x1 - y1 - b0 + b1 * pow2 56) * pow2 56 +
(x2 - y2 - b1 + b2 * pow2 5... | false |
SfBasic.fst | SfBasic.plus_rearrange | val plus_rearrange : n : nat -> m : nat -> p : nat -> q : nat -> Lemma
(ensures (plus (plus n m) (plus p q) = plus (plus m n) (plus p q))) | val plus_rearrange : n : nat -> m : nat -> p : nat -> q : nat -> Lemma
(ensures (plus (plus n m) (plus p q) = plus (plus m n) (plus p q))) | let plus_rearrange n m p q = plus_comm n m | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 230,
"start_col": 0,
"start_line": 230
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: SfBasic.nat -> m: SfBasic.nat -> p: SfBasic.nat -> q: SfBasic.nat
-> FStar.Pervasives.Lemma
(ensures
SfBasic.plus (SfBasic.plus n m) (SfBasic.plus p q) =
SfBasic.plus (SfBasic.plus m n) (SfBasic.plus p q)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"SfBasic.nat",
"SfBasic.plus_comm",
"Prims.unit"
] | [] | true | false | true | false | false | let plus_rearrange n m p q =
| plus_comm n m | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_div248_x7 | val lemma_div248_x7: x7:uint64 ->
Lemma (pow2 32 * (v x7 % pow2 24) * pow2 112 + v x7 / pow2 24 * pow2 168 == v x7 * pow2 144) | val lemma_div248_x7: x7:uint64 ->
Lemma (pow2 32 * (v x7 % pow2 24) * pow2 112 + v x7 / pow2 24 * pow2 168 == v x7 * pow2 144) | let lemma_div248_x7 x7 =
calc (==) {
pow2 32 * (v x7 % pow2 24) * pow2 112 + v x7 / pow2 24 * pow2 168;
(==) { _ by (Tactics.norm [delta_only [`%pow2]; primops]; int_semiring ()) }
((v x7 / pow2 24) * pow2 24 + v x7 % pow2 24) * pow2 144;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v x7) (... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 188,
"start_col": 0,
"start_line": 181
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x7: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(Prims.pow2 32 * (Lib.IntTypes.v x7 % Prims.pow2 24)) * Prims.pow2 112 +
(Lib.IntTypes.v x7 / Prims.pow2 24) * Prims.pow2 168 ==
Lib.IntTypes.v x7 * Prims.pow2 144) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.uint64",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Modulus",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_Division",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"P... | [] | false | false | true | false | false | let lemma_div248_x7 x7 =
| calc ( == ) {
(pow2 32 * (v x7 % pow2 24)) * pow2 112 + (v x7 / pow2 24) * pow2 168;
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ ->
(Tactics.norm [delta_only [`%pow2]; primops];
int_semiring ())) }
((v x7 / pow2 24) * pow2 24 + v x7 % pow2 24) * pow2 144;
( == ) { FStar.Math.Lemmas.eu... | false |
SfBasic.fst | SfBasic.plus_comm | val plus_comm : n : nat -> m : nat -> Lemma
(ensures (plus n m = plus m n)) | val plus_comm : n : nat -> m : nat -> Lemma
(ensures (plus n m = plus m n)) | let rec plus_comm n m =
match n with
| O -> plus_0_r m
| S n' -> plus_comm n' m; plus_n_Sm m n' | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 225,
"start_col": 0,
"start_line": 222
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: SfBasic.nat -> m: SfBasic.nat
-> FStar.Pervasives.Lemma (ensures SfBasic.plus n m = SfBasic.plus m n) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"SfBasic.nat",
"SfBasic.plus_0_r",
"SfBasic.plus_n_Sm",
"Prims.unit",
"SfBasic.plus_comm"
] | [
"recursion"
] | false | false | true | false | false | let rec plus_comm n m =
| match n with
| O -> plus_0_r m
| S n' ->
plus_comm n' m;
plus_n_Sm m n' | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_mod_264'' | val lemma_mod_264'':
a0:nat -> a1:nat-> a2:nat -> a3:nat -> a4:nat ->
Lemma
(requires a0 < pow56 /\ a1 < pow56 /\ a2 < pow56 /\ a3 < pow56)
(ensures a0 + pow2 56 * a1 + pow2 112 * a2 + pow2 168 * a3 + pow2 224 * (a4 % pow2 40) < pow2 264) | val lemma_mod_264'':
a0:nat -> a1:nat-> a2:nat -> a3:nat -> a4:nat ->
Lemma
(requires a0 < pow56 /\ a1 < pow56 /\ a2 < pow56 /\ a3 < pow56)
(ensures a0 + pow2 56 * a1 + pow2 112 * a2 + pow2 168 * a3 + pow2 224 * (a4 % pow2 40) < pow2 264) | let lemma_mod_264'' a0 a1 a2 a3 a4 =
assert_norm(pow2 40 = 0x10000000000);
assert_norm(pow2 56 = 0x100000000000000);
assert_norm(pow2 112 = 0x10000000000000000000000000000);
assert_norm(pow2 168 = 0x1000000000000000000000000000000000000000000);
assert_norm(pow2 224 = 0x1000000000000000000000000000000000000000... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 95,
"end_line": 712,
"start_col": 0,
"start_line": 706
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a0: Prims.nat -> a1: Prims.nat -> a2: Prims.nat -> a3: Prims.nat -> a4: Prims.nat
-> FStar.Pervasives.Lemma
(requires
a0 < Hacl.Spec.BignumQ.Definitions.pow56 /\ a1 < Hacl.Spec.BignumQ.Definitions.pow56 /\
a2 < Hacl.Spec.BignumQ.Definitions.pow56 /\ a3 < Hacl.Spec.BignumQ.Definitions.pow56)
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.pow2",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_mod_264'' a0 a1 a2 a3 a4 =
| assert_norm (pow2 40 = 0x10000000000);
assert_norm (pow2 56 = 0x100000000000000);
assert_norm (pow2 112 = 0x10000000000000000000000000000);
assert_norm (pow2 168 = 0x1000000000000000000000000000000000000000000);
assert_norm (pow2 224 = 0x100000000000000000000000000000000000000000000000000000000);
assert_norm (pow2 264 ... | false |
SfBasic.fst | SfBasic.plus_n_Sm | val plus_n_Sm : n : nat -> m : nat -> Lemma
(ensures (S (plus n m) = plus n (S m))) | val plus_n_Sm : n : nat -> m : nat -> Lemma
(ensures (S (plus n m) = plus n (S m))) | let rec plus_n_Sm n m =
match n with
| O -> ()
| S n' -> plus_n_Sm n' m | {
"file_name": "examples/software_foundations/SfBasic.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 217,
"start_col": 0,
"start_line": 214
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SfBasic.fst"
} | [
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: SfBasic.nat -> m: SfBasic.nat
-> FStar.Pervasives.Lemma (ensures SfBasic.S (SfBasic.plus n m) = SfBasic.plus n (SfBasic.S m)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"SfBasic.nat",
"SfBasic.plus_n_Sm",
"Prims.unit"
] | [
"recursion"
] | false | false | true | false | false | let rec plus_n_Sm n m =
| match n with
| O -> ()
| S n' -> plus_n_Sm n' m | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_div264_x6 | val lemma_div264_x6: x6:uint64 ->
Lemma (pow2 16 * (v x6 % pow2 40) * pow2 56 + v x6 / pow2 40 * pow2 112 == v x6 * pow2 72) | val lemma_div264_x6: x6:uint64 ->
Lemma (pow2 16 * (v x6 % pow2 40) * pow2 56 + v x6 / pow2 40 * pow2 112 == v x6 * pow2 72) | let lemma_div264_x6 x6 =
calc (==) {
pow2 16 * (v x6 % pow2 40) * pow2 56 + v x6 / pow2 40 * pow2 112;
(==) { _ by (Tactics.norm [delta; primops]; int_semiring ()) }
((v x6 / pow2 40) * pow2 40 + v x6 % pow2 40) * pow2 72;
(==) { Math.Lemmas.euclidean_division_definition (v x6) (pow2 40) }
v x6 * ... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 381,
"start_col": 0,
"start_line": 374
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x6: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(Prims.pow2 16 * (Lib.IntTypes.v x6 % Prims.pow2 40)) * Prims.pow2 56 +
(Lib.IntTypes.v x6 / Prims.pow2 40) * Prims.pow2 112 ==
Lib.IntTypes.v x6 * Prims.pow2 72) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.uint64",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Modulus",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_Division",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"P... | [] | false | false | true | false | false | let lemma_div264_x6 x6 =
| calc ( == ) {
(pow2 16 * (v x6 % pow2 40)) * pow2 56 + (v x6 / pow2 40) * pow2 112;
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ ->
(Tactics.norm [delta; primops];
int_semiring ())) }
((v x6 / pow2 40) * pow2 40 + v x6 % pow2 40) * pow2 72;
( == ) { Math.Lemmas.euclidean_division_defin... | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_div264_x7 | val lemma_div264_x7: x7:uint64 ->
Lemma (pow2 16 * (v x7 % pow2 40) * pow2 112 + v x7 / pow2 40 * pow2 168 == v x7 * pow2 128) | val lemma_div264_x7: x7:uint64 ->
Lemma (pow2 16 * (v x7 % pow2 40) * pow2 112 + v x7 / pow2 40 * pow2 168 == v x7 * pow2 128) | let lemma_div264_x7 x7 =
calc (==) {
pow2 16 * (v x7 % pow2 40) * pow2 112 + v x7 / pow2 40 * pow2 168;
(==) { _ by (Tactics.norm [delta; primops]; int_semiring ()) }
((v x7 / pow2 40) * pow2 40 + v x7 % pow2 40) * pow2 128;
(==) { Math.Lemmas.euclidean_division_definition (v x7) (pow2 40) }
v x7 ... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 393,
"start_col": 0,
"start_line": 386
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x7: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(Prims.pow2 16 * (Lib.IntTypes.v x7 % Prims.pow2 40)) * Prims.pow2 112 +
(Lib.IntTypes.v x7 / Prims.pow2 40) * Prims.pow2 168 ==
Lib.IntTypes.v x7 * Prims.pow2 128) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.uint64",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Modulus",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_Division",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"P... | [] | false | false | true | false | false | let lemma_div264_x7 x7 =
| calc ( == ) {
(pow2 16 * (v x7 % pow2 40)) * pow2 112 + (v x7 / pow2 40) * pow2 168;
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ ->
(Tactics.norm [delta; primops];
int_semiring ())) }
((v x7 / pow2 40) * pow2 40 + v x7 % pow2 40) * pow2 128;
( == ) { Math.Lemmas.euclidean_division_def... | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_div264_x9 | val lemma_div264_x9: x9:uint64{v x9 < pow2 40} ->
Lemma (pow2 16 * (v x9 % pow2 40) * pow2 224 == v x9 * pow2 240) | val lemma_div264_x9: x9:uint64{v x9 < pow2 40} ->
Lemma (pow2 16 * (v x9 % pow2 40) * pow2 224 == v x9 * pow2 240) | let lemma_div264_x9 x9 =
calc (==) {
pow2 16 * (v x9 % pow2 40) * pow2 224;
(==) { Math.Lemmas.small_mod (v x9) (pow2 40) }
pow2 16 * v x9 * pow2 224;
(==) { _ by (Tactics.norm [delta; primops]; int_semiring ()) }
v x9 * pow2 240;
} | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 416,
"start_col": 0,
"start_line": 409
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x9: Lib.IntTypes.uint64{Lib.IntTypes.v x9 < Prims.pow2 40}
-> FStar.Pervasives.Lemma
(ensures
(Prims.pow2 16 * (Lib.IntTypes.v x9 % Prims.pow2 40)) * Prims.pow2 224 ==
Lib.IntTypes.v x9 * Prims.pow2 240) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.uint64",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.uni... | [] | false | false | true | false | false | let lemma_div264_x9 x9 =
| calc ( == ) {
(pow2 16 * (v x9 % pow2 40)) * pow2 224;
( == ) { Math.Lemmas.small_mod (v x9) (pow2 40) }
(pow2 16 * v x9) * pow2 224;
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ ->
(Tactics.norm [delta; primops];
int_semiring ())) }
v x9 * pow2 240;
} | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_div248_x9 | val lemma_div248_x9: x9:uint64{v x9 < pow2 24} ->
Lemma (pow2 32 * (v x9 % pow2 24) * pow2 224 == v x9 * pow2 256) | val lemma_div248_x9: x9:uint64{v x9 < pow2 24} ->
Lemma (pow2 32 * (v x9 % pow2 24) * pow2 224 == v x9 * pow2 256) | let lemma_div248_x9 x9 =
calc (==) {
pow2 32 * (v x9 % pow2 24) * pow2 224;
(==) { Math.Lemmas.small_mod (v x9) (pow2 24) }
pow2 32 * v x9 * pow2 224;
(==) { _ by (Tactics.norm [delta; primops]; int_semiring ()) }
v x9 * pow2 256;
} | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 212,
"start_col": 0,
"start_line": 205
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x9: Lib.IntTypes.uint64{Lib.IntTypes.v x9 < Prims.pow2 24}
-> FStar.Pervasives.Lemma
(ensures
(Prims.pow2 32 * (Lib.IntTypes.v x9 % Prims.pow2 24)) * Prims.pow2 224 ==
Lib.IntTypes.v x9 * Prims.pow2 256) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.uint64",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.uni... | [] | false | false | true | false | false | let lemma_div248_x9 x9 =
| calc ( == ) {
(pow2 32 * (v x9 % pow2 24)) * pow2 224;
( == ) { Math.Lemmas.small_mod (v x9) (pow2 24) }
(pow2 32 * v x9) * pow2 224;
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ ->
(Tactics.norm [delta; primops];
int_semiring ())) }
v x9 * pow2 256;
} | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_div248_x8 | val lemma_div248_x8: x8:uint64 ->
Lemma (pow2 32 * (v x8 % pow2 24) * pow2 168 + v x8 / pow2 24 * pow2 224 == v x8 * pow2 200) | val lemma_div248_x8: x8:uint64 ->
Lemma (pow2 32 * (v x8 % pow2 24) * pow2 168 + v x8 / pow2 24 * pow2 224 == v x8 * pow2 200) | let lemma_div248_x8 x8 =
calc (==) {
pow2 32 * (v x8 % pow2 24) * pow2 168 + v x8 / pow2 24 * pow2 224;
(==) { _ by (Tactics.norm [delta_only [`%pow2]; primops]; int_semiring ()) }
((v x8 / pow2 24) * pow2 24 + v x8 % pow2 24) * pow2 200;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v x8) (... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 200,
"start_col": 0,
"start_line": 193
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x8: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(Prims.pow2 32 * (Lib.IntTypes.v x8 % Prims.pow2 24)) * Prims.pow2 168 +
(Lib.IntTypes.v x8 / Prims.pow2 24) * Prims.pow2 224 ==
Lib.IntTypes.v x8 * Prims.pow2 200) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.uint64",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Modulus",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_Division",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"P... | [] | false | false | true | false | false | let lemma_div248_x8 x8 =
| calc ( == ) {
(pow2 32 * (v x8 % pow2 24)) * pow2 168 + (v x8 / pow2 24) * pow2 224;
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ ->
(Tactics.norm [delta_only [`%pow2]; primops];
int_semiring ())) }
((v x8 / pow2 24) * pow2 24 + v x8 % pow2 24) * pow2 200;
( == ) { FStar.Math.Lemmas.eu... | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_mod_264' | val lemma_mod_264':
a0:nat -> a1:nat-> a2:nat -> a3:nat -> a4:nat ->
Lemma
(requires a0 < pow56 /\ a1 < pow56 /\ a2 < pow56 /\ a3 < pow56)
(ensures (a0
+ pow2 56 * a1
+ pow2 112 * a2
+ pow2 168 * a3
+ pow2 224 * a4) % pow2 264 =
a0
+ pow2 56 * a1
+ pow2 112 *... | val lemma_mod_264':
a0:nat -> a1:nat-> a2:nat -> a3:nat -> a4:nat ->
Lemma
(requires a0 < pow56 /\ a1 < pow56 /\ a2 < pow56 /\ a3 < pow56)
(ensures (a0
+ pow2 56 * a1
+ pow2 112 * a2
+ pow2 168 * a3
+ pow2 224 * a4) % pow2 264 =
a0
+ pow2 56 * a1
+ pow2 112 *... | let lemma_mod_264' a0 a1 a2 a3 a4 =
assert_norm(pow2 56 = 0x100000000000000);
assert_norm(pow2 112 = 0x10000000000000000000000000000);
assert_norm(pow2 168 = 0x1000000000000000000000000000000000000000000);
assert_norm(pow2 224 = 0x100000000000000000000000000000000000000000000000000000000);
Math.Lemmas.lemma_m... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 117,
"end_line": 737,
"start_col": 0,
"start_line": 729
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a0: Prims.nat -> a1: Prims.nat -> a2: Prims.nat -> a3: Prims.nat -> a4: Prims.nat
-> FStar.Pervasives.Lemma
(requires
a0 < Hacl.Spec.BignumQ.Definitions.pow56 /\ a1 < Hacl.Spec.BignumQ.Definitions.pow56 /\
a2 < Hacl.Spec.BignumQ.Definitions.pow56 /\ a3 < Hacl.Spec.BignumQ.Definitions.pow56)
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"FStar.Math.Lemmas.modulo_lemma",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Modulus",
"Prims.unit",
"Hacl.Spec.BignumQ.Lemmas.lemma_mod_264''",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2",
"FStar.Math.Lemmas.lemma_mod_plus_distr_l",
"FStar.Pervasiv... | [] | true | false | true | false | false | let lemma_mod_264' a0 a1 a2 a3 a4 =
| assert_norm (pow2 56 = 0x100000000000000);
assert_norm (pow2 112 = 0x10000000000000000000000000000);
assert_norm (pow2 168 = 0x1000000000000000000000000000000000000000000);
assert_norm (pow2 224 = 0x100000000000000000000000000000000000000000000000000000000);
Math.Lemmas.lemma_mod_plus_distr_l (pow2 224 * a4)
(a0 + po... | false |
Steel.ST.SeqMatch.fst | Steel.ST.SeqMatch.seq_seq_match_item_match_option_index | val seq_seq_match_item_match_option_index
(#opened: _)
(#t1 #t2: Type)
(p: (t1 -> t2 -> vprop))
(s1: Seq.seq t1)
(s2: Seq.seq (option t2))
(i j: nat)
(k: nat{i <= j /\ j < k /\ (j < Seq.length s2 ==> Some? (Seq.index s2 j))})
: STGhostT (squash (j < Seq.length s1 /\ j < Seq... | val seq_seq_match_item_match_option_index
(#opened: _)
(#t1 #t2: Type)
(p: (t1 -> t2 -> vprop))
(s1: Seq.seq t1)
(s2: Seq.seq (option t2))
(i j: nat)
(k: nat{i <= j /\ j < k /\ (j < Seq.length s2 ==> Some? (Seq.index s2 j))})
: STGhostT (squash (j < Seq.length s1 /\ j < Seq... | let seq_seq_match_item_match_option_index
(#opened: _)
(#t1 #t2: Type)
(p: t1 -> t2 -> vprop)
(s1: Seq.seq t1)
(s2: Seq.seq (option t2))
(i j: nat)
(k: nat {
i <= j /\ j < k /\
(j < Seq.length s2 ==> Some? (Seq.index s2 j))
})
: STGhostT (squash (j < Seq.length s1 /\ j < Seq.length s2 /\ Some? (... | {
"file_name": "lib/steel/Steel.ST.SeqMatch.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 5,
"end_line": 792,
"start_col": 0,
"start_line": 751
} | module Steel.ST.SeqMatch
include Steel.ST.OnRange
open Steel.ST.GenElim
module Seq = FStar.Seq
module SZ = FStar.SizeT
(* `seq_list_match` describes how to match a sequence of low-level
values (the low-level contents of an array) with a list of high-level
values. `seq_list_match` is carefully designed to be usable wi... | {
"checked_file": "/",
"dependencies": [
"Steel.ST.OnRange.fsti.checked",
"Steel.ST.GenElim.fsti.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_fil... | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "SZ"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "Steel.ST.GenElim",
"short_module": null
},
{
"abbrev": false,
"full_module": "Stee... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: (_: t1 -> _: t2 -> Steel.Effect.Common.vprop) ->
s1: FStar.Seq.Base.seq t1 ->
s2: FStar.Seq.Base.seq (FStar.Pervasives.Native.option t2) ->
i: Prims.nat ->
j: Prims.nat ->
k:
Prims.nat
{i <= j /\ j < k /\ (j < FStar.Seq.Base.length s2 ==> Some? (FStar.Seq.Base.index s2 j))}
-... | Steel.ST.Effect.Ghost.STGhostT | [] | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"FStar.Seq.Base.seq",
"FStar.Pervasives.Native.option",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.l_imp",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Seq.Bas... | [] | false | true | true | false | false | let seq_seq_match_item_match_option_index
(#opened: _)
(#t1 #t2: Type)
(p: (t1 -> t2 -> vprop))
(s1: Seq.seq t1)
(s2: Seq.seq (option t2))
(i j: nat)
(k: nat{i <= j /\ j < k /\ (j < Seq.length s2 ==> Some? (Seq.index s2 j))})
: STGhostT (squash (j < Seq.length s1 /\ j < Seq... | seq_seq_match_length (item_match_option p) s1 s2 i k;
on_range_get (seq_seq_match_item (item_match_option p) s1 s2) i j (j + 1) k;
let res:squash (j < Seq.length s1 /\ j < Seq.length s2 /\ Some? (Seq.index s2 j)) = () in
rewrite (seq_seq_match_item (item_match_option p) s1 s2 j)
(p (Seq.index s1 j) (Some?.v (Seq.inde... | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_aux_0 | val lemma_aux_0 (a b n: nat)
: Lemma
(pow2 n * a + pow2 (n + 56) * b = pow2 n * (a % pow2 56) + pow2 (n + 56) * (b + a / pow2 56)) | val lemma_aux_0 (a b n: nat)
: Lemma
(pow2 n * a + pow2 (n + 56) * b = pow2 n * (a % pow2 56) + pow2 (n + 56) * (b + a / pow2 56)) | let lemma_aux_0 (a:nat) (b:nat) (n:nat) : Lemma
(pow2 n * a + pow2 (n+56) * b = pow2 n * (a % pow2 56) + pow2 (n+56) * (b + a / pow2 56))
= Math.Lemmas.lemma_div_mod a (pow2 56);
Math.Lemmas.pow2_plus n 56;
assert(a = pow2 56 * (a / pow2 56) + (a % pow2 56));
Math.Lemmas.distributivity_add_right (pow2 n... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 70,
"end_line": 746,
"start_col": 8,
"start_line": 739
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Prims.nat -> b: Prims.nat -> n: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
Prims.pow2 n * a + Prims.pow2 (n + 56) * b =
Prims.pow2 n * (a % Prims.pow2 56) + Prims.pow2 (n + 56) * (b + a / Prims.pow2 56)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"FStar.Math.Lemmas.distributivity_add_right",
"Prims.pow2",
"Prims.op_Addition",
"Prims.op_Division",
"Prims.unit",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Math.Lemmas.... | [] | true | false | true | false | false | let lemma_aux_0 (a b n: nat)
: Lemma
(pow2 n * a + pow2 (n + 56) * b = pow2 n * (a % pow2 56) + pow2 (n + 56) * (b + a / pow2 56)) =
| Math.Lemmas.lemma_div_mod a (pow2 56);
Math.Lemmas.pow2_plus n 56;
assert (a = pow2 56 * (a / pow2 56) + (a % pow2 56));
Math.Lemmas.distributivity_add_right (pow2 n) (pow2 56 * (a / pow2 56)) (a % pow2 56);
Math.Lemmas.paren_mul_right (pow2 n) (pow2 56) (a / pow2 56);
Math.Lemmas.distributivity_add_right (pow2 (n + 56... | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_1 | val lemma_1 (x y: nat) (c: pos)
: Lemma (requires (x - y < c /\ x >= y))
(ensures
(x - y = (if (x % c) - (y % c) < 0 then c + (x % c) - (y % c) else (x % c) - (y % c)))) | val lemma_1 (x y: nat) (c: pos)
: Lemma (requires (x - y < c /\ x >= y))
(ensures
(x - y = (if (x % c) - (y % c) < 0 then c + (x % c) - (y % c) else (x % c) - (y % c)))) | let lemma_1 (x:nat) (y:nat) (c:pos) : Lemma
(requires (x - y < c /\ x >= y))
(ensures (x - y = (if (x % c) - (y % c) < 0 then c + (x % c) - (y % c)
else (x % c) - (y % c))))
= Math.Lemmas.lemma_div_mod x c;
Math.Lemmas.lemma_div_mod y c;
Math.Lemmas.distributivity_sub_right c (y/c) (x/c);
... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 17,
"end_line": 864,
"start_col": 0,
"start_line": 856
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat -> y: Prims.nat -> c: Prims.pos
-> FStar.Pervasives.Lemma (requires x - y < c /\ x >= y)
(ensures
x - y =
(match x % c - y % c < 0 with
| true -> c + x % c - y % c
| _ -> x % c - y % c)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.pos",
"Hacl.Spec.BignumQ.Lemmas.lemma_0",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Subtraction",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Prims.op_Division",
"FStar.Math.Lemmas.distributivity_sub_right",
"FStar.Math.Lemmas... | [] | true | false | true | false | false | let lemma_1 (x y: nat) (c: pos)
: Lemma (requires (x - y < c /\ x >= y))
(ensures
(x - y = (if (x % c) - (y % c) < 0 then c + (x % c) - (y % c) else (x % c) - (y % c)))) =
| Math.Lemmas.lemma_div_mod x c;
Math.Lemmas.lemma_div_mod y c;
Math.Lemmas.distributivity_sub_right c (y / c) (x / c);
assert ((x % c) - (y % c) = x - y - c * ((x / c) - (y / c)));
lemma_0 x y c | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_mul_qelem5 | val lemma_mul_qelem5 (x0 x1 x2 x3 x4 y0 y1 y2 y3 y4: nat)
: Lemma
((x0 + x1 * pow2 56 + x2 * pow2 112 + x3 * pow2 168 + x4 * pow2 224) *
(y0 + y1 * pow2 56 + y2 * pow2 112 + y3 * pow2 168 + y4 * pow2 224) ==
x0 * y0 + (x0 * y1 + x1 * y0) * pow56 + (x0 * y2 + x1 * y1 + x2 * y0) * pow112 +
(x0 *... | val lemma_mul_qelem5 (x0 x1 x2 x3 x4 y0 y1 y2 y3 y4: nat)
: Lemma
((x0 + x1 * pow2 56 + x2 * pow2 112 + x3 * pow2 168 + x4 * pow2 224) *
(y0 + y1 * pow2 56 + y2 * pow2 112 + y3 * pow2 168 + y4 * pow2 224) ==
x0 * y0 + (x0 * y1 + x1 * y0) * pow56 + (x0 * y2 + x1 * y1 + x2 * y0) * pow112 +
(x0 *... | let lemma_mul_qelem5 (x0 x1 x2 x3 x4 y0 y1 y2 y3 y4:nat) : Lemma
((x0 + x1 * pow2 56 + x2 * pow2 112 + x3 * pow2 168 + x4 * pow2 224) *
(y0 + y1 * pow2 56 + y2 * pow2 112 + y3 * pow2 168 + y4 * pow2 224) ==
x0 * y0 +
(x0 * y1 + x1 * y0) * pow56 +
(x0 * y2 + x1 * y1 + x2 * y0) * pow112 +
(x0 * y3 +... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 65,
"end_line": 637,
"start_col": 0,
"start_line": 613
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
x0: Prims.nat ->
x1: Prims.nat ->
x2: Prims.nat ->
x3: Prims.nat ->
x4: Prims.nat ->
y0: Prims.nat ->
y1: Prims.nat ->
y2: Prims.nat ->
y3: Prims.nat ->
y4: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
(x0 + x1 * Prims.pow2 56 + x2 * Prims.pow2 112 + x3 * Prims.pow2 ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"Prims.int",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Prims.pow2",
"Hacl.Spec.BignumQ.Definitions.pow56",
"Hacl.Spec.BignumQ.Definitions.pow112",
"Hacl.Spec.BignumQ.Definitions.pow168",
"Hacl.Spec.BignumQ.Definitions.pow224",
... | [] | false | false | true | false | false | let lemma_mul_qelem5 (x0 x1 x2 x3 x4 y0 y1 y2 y3 y4: nat)
: Lemma
((x0 + x1 * pow2 56 + x2 * pow2 112 + x3 * pow2 168 + x4 * pow2 224) *
(y0 + y1 * pow2 56 + y2 * pow2 112 + y3 * pow2 168 + y4 * pow2 224) ==
x0 * y0 + (x0 * y1 + x1 * y0) * pow56 + (x0 * y2 + x1 * y1 + x2 * y0) * pow112 +
(x0 *... | FStar.Tactics.Effect.assert_by_tactic ((x0 + x1 * pow2 56 + x2 * pow2 112 + x3 * pow2 168 +
x4 * pow2 224) *
(y0 + y1 * pow2 56 + y2 * pow2 112 + y3 * pow2 168 + y4 * pow2 224) ==
x0 * y0 + (x0 * y1 + x1 * y0) * pow56 + (x0 * y2 + x1 * y1 + x2 * y0) * pow112 +
(x0 * y3 + x1 * y2 + x2 * y1 + x3 * y0) *... | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_mod_264_ | val lemma_mod_264_:
a0:nat -> a1:nat -> a2:nat -> a3:nat -> a4:nat ->
Lemma ((a0 + pow2 56 * a1 + pow2 112 * a2 + pow2 168 * a3 + pow2 224 * a4) % pow2 264 =
(a0 % pow2 56)
+ pow2 56 * ((a1 + (a0 / pow2 56)) % pow2 56)
+ pow2 112 * ((a2 + ((a1 + (a0 / pow2 56)) / pow2 56)) % pow2 56)
+ p... | val lemma_mod_264_:
a0:nat -> a1:nat -> a2:nat -> a3:nat -> a4:nat ->
Lemma ((a0 + pow2 56 * a1 + pow2 112 * a2 + pow2 168 * a3 + pow2 224 * a4) % pow2 264 =
(a0 % pow2 56)
+ pow2 56 * ((a1 + (a0 / pow2 56)) % pow2 56)
+ pow2 112 * ((a2 + ((a1 + (a0 / pow2 56)) / pow2 56)) % pow2 56)
+ p... | let lemma_mod_264_ a0 a1 a2 a3 a4 =
lemma_mod_264_small a0 a1 a2 a3 a4;
let x0 = a0 % pow2 56 in
assert (x0 < pow56);
let x1 = ((a1 + (a0 / pow2 56)) % pow2 56) in
assert (x1 < pow56);
let x2 = ((a2 + ((a1 + (a0 / pow2 56)) / pow2 56)) % pow2 56) in
assert (x2 < pow56);
let x3 = ((a3 + ((a2 + ((a1 + (a... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 107,
"end_line": 798,
"start_col": 0,
"start_line": 788
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a0: Prims.nat -> a1: Prims.nat -> a2: Prims.nat -> a3: Prims.nat -> a4: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
(a0 + Prims.pow2 56 * a1 + Prims.pow2 112 * a2 + Prims.pow2 168 * a3 + Prims.pow2 224 * a4) %
Prims.pow2 264 =
a0 % Prims.pow2 56 + Prims.pow2 56 * ((a1 + a0 / Prims.pow2 56) % Pr... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Hacl.Spec.BignumQ.Lemmas.lemma_mod_264'",
"Prims.op_Addition",
"Prims.op_Division",
"Prims.pow2",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.BignumQ.Definitions.pow56",
"Prims.int",
"Prims.op_Modulus",
"Hacl.Spec.BignumQ.Lemmas.lemma_mod_264_sma... | [] | true | false | true | false | false | let lemma_mod_264_ a0 a1 a2 a3 a4 =
| lemma_mod_264_small a0 a1 a2 a3 a4;
let x0 = a0 % pow2 56 in
assert (x0 < pow56);
let x1 = ((a1 + (a0 / pow2 56)) % pow2 56) in
assert (x1 < pow56);
let x2 = ((a2 + ((a1 + (a0 / pow2 56)) / pow2 56)) % pow2 56) in
assert (x2 < pow56);
let x3 = ((a3 + ((a2 + ((a1 + (a0 / pow2 56)) / pow2 56)) / pow2 56)) % pow2 56) in
a... | false |
Monad.fst | Monad.f | val f (#a #b #m: _) {| _: monad m |} (x: m (a -> b)) (y: m a) : m b | val f (#a #b #m: _) {| _: monad m |} (x: m (a -> b)) (y: m a) : m b | let f #a #b #m {| monad m |} (x : m (a -> b)) (y : m a) : m b =
bind #m x (fun x ->
bind #m y (fun y ->
return #m (x y))) | {
"file_name": "examples/typeclasses/Monad.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 49,
"start_col": 0,
"start_line": 46
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Functor.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Monad.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.Typeclasses",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | {| _: Monad.monad m |} -> x: m (_: a -> b) -> y: m a -> m b | Prims.Tot | [
"total"
] | [] | [
"Monad.monad",
"Monad.bind",
"Monad.return"
] | [] | false | false | false | false | false | let f #a #b #m {| _: monad m |} (x: m (a -> b)) (y: m a) : m b =
| bind #m x (fun x -> bind #m y (fun y -> return #m (x y))) | false |
Monad.fst | Monad.monad_functor | [@@ FStar.Tactics.Typeclasses.tcinstance]
val monad_functor (#m: _) (d: monad m) : functor m | [@@ FStar.Tactics.Typeclasses.tcinstance]
val monad_functor (#m: _) (d: monad m) : functor m | instance monad_functor #m (d : monad m) : functor m =
{ fmap = (fun #_ #_ f x -> bind #m x (fun xx -> return #m (f xx))); } | {
"file_name": "examples/typeclasses/Monad.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 71,
"end_line": 65,
"start_col": 0,
"start_line": 64
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Functor.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Monad.fst"
} | [
{
"abbrev": false,
"full_module": "Functor",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Typeclasses",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | d: Monad.monad m -> Functor.functor m | Prims.Tot | [
"total"
] | [] | [
"Monad.monad",
"Functor.Mkfunctor",
"Monad.bind",
"Monad.return",
"Functor.functor"
] | [] | false | false | false | false | false | [@@ FStar.Tactics.Typeclasses.tcinstance]
let monad_functor #m (d: monad m) : functor m =
| { fmap = (fun #_ #_ f x -> bind #m x (fun xx -> return #m (f xx))) } | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_0 | val lemma_0 (x y: nat) (c: pos)
: Lemma (requires (x >= y /\ x - y < c)) (ensures (x / c - y / c <= 1)) | val lemma_0 (x y: nat) (c: pos)
: Lemma (requires (x >= y /\ x - y < c)) (ensures (x / c - y / c <= 1)) | let lemma_0 (x:nat) (y:nat) (c:pos) : Lemma
(requires (x >= y /\ x - y < c))
(ensures (x / c - y / c <= 1))
= if x / c - y / c > 1 then (
Math.Lemmas.lemma_div_mod x c;
Math.Lemmas.lemma_div_mod y c;
Math.Lemmas.distributivity_sub_right c (x / c) (y / c);
Math.Lemmas.lemma_div_mod (x-y) c;... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 7,
"end_line": 851,
"start_col": 0,
"start_line": 840
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat -> y: Prims.nat -> c: Prims.pos
-> FStar.Pervasives.Lemma (requires x >= y /\ x - y < c) (ensures x / c - y / c <= 1) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.pos",
"Prims.op_GreaterThan",
"Prims.op_Subtraction",
"Prims.op_Division",
"FStar.Math.Lemmas.cancel_mul_div",
"Prims.unit",
"FStar.Math.Lemmas.swap_mul",
"FStar.Math.Lemmas.small_div",
"FStar.Math.Lemmas.lemma_div_mod",
"FStar.Math.Lemmas.distributivity_sub_right",
"Prims.... | [] | false | false | true | false | false | let lemma_0 (x y: nat) (c: pos)
: Lemma (requires (x >= y /\ x - y < c)) (ensures (x / c - y / c <= 1)) =
| if x / c - y / c > 1
then
(Math.Lemmas.lemma_div_mod x c;
Math.Lemmas.lemma_div_mod y c;
Math.Lemmas.distributivity_sub_right c (x / c) (y / c);
Math.Lemmas.lemma_div_mod (x - y) c;
Math.Lemmas.small_div (x - y) c;
Math.Lemmas.swap_mul c (x / c - y / c);
Math.Lemmas.cancel_mul_div (x / c - y /... | false |
LowParse.Low.ConstInt32.fst | LowParse.Low.ConstInt32.decompose_int32le_1 | val decompose_int32le_1 (v: nat{0 <= v /\ v < 4294967296}) : Tot (b1: nat{0 <= b1 /\ b1 < 256}) | val decompose_int32le_1 (v: nat{0 <= v /\ v < 4294967296}) : Tot (b1: nat{0 <= b1 /\ b1 < 256}) | let decompose_int32le_1
(v: nat { 0 <= v /\ v < 4294967296 } )
: Tot (b1: nat { 0 <= b1 /\ b1 < 256 } )
= v / 256 % 256 | {
"file_name": "src/lowparse/LowParse.Low.ConstInt32.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 15,
"end_line": 71,
"start_col": 0,
"start_line": 68
} | module LowParse.Low.ConstInt32
(* LowParse implementation module for 32 bits contants *)
include FStar.Endianness
include LowParse.Spec.ConstInt32
include LowParse.Spec.Int32le
include LowParse.Low.Combinators
include LowParse.Low.Int32le
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStac... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Int32le.fst.checked",
"LowParse.Spec.ConstInt32.fst.checked",
"LowParse.Low.Int32le.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UIn... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | v: Prims.nat{0 <= v /\ v < 4294967296} -> b1: Prims.nat{0 <= b1 /\ b1 < 256} | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Modulus",
"Prims.op_Division"
] | [] | false | false | false | false | false | let decompose_int32le_1 (v: nat{0 <= v /\ v < 4294967296}) : Tot (b1: nat{0 <= b1 /\ b1 < 256}) =
| v / 256 % 256 | false |
LowParse.Low.ConstInt32.fst | LowParse.Low.ConstInt32.decompose_int32le_0 | val decompose_int32le_0 (v: nat{0 <= v /\ v < 4294967296}) : Tot (b0: nat{0 <= b0 /\ b0 < 256}) | val decompose_int32le_0 (v: nat{0 <= v /\ v < 4294967296}) : Tot (b0: nat{0 <= b0 /\ b0 < 256}) | let decompose_int32le_0
(v: nat { 0 <= v /\ v < 4294967296 } )
: Tot (b0: nat { 0 <= b0 /\ b0 < 256 } )
= v % 256 | {
"file_name": "src/lowparse/LowParse.Low.ConstInt32.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 9,
"end_line": 65,
"start_col": 0,
"start_line": 62
} | module LowParse.Low.ConstInt32
(* LowParse implementation module for 32 bits contants *)
include FStar.Endianness
include LowParse.Spec.ConstInt32
include LowParse.Spec.Int32le
include LowParse.Low.Combinators
include LowParse.Low.Int32le
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStac... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Int32le.fst.checked",
"LowParse.Spec.ConstInt32.fst.checked",
"LowParse.Low.Int32le.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UIn... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | v: Prims.nat{0 <= v /\ v < 4294967296} -> b0: Prims.nat{0 <= b0 /\ b0 < 256} | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Modulus"
] | [] | false | false | false | false | false | let decompose_int32le_0 (v: nat{0 <= v /\ v < 4294967296}) : Tot (b0: nat{0 <= b0 /\ b0 < 256}) =
| v % 256 | false |
Monad.fst | Monad.g' | val g' : {| _: Monad.monad m |} -> x: m a -> Prims.unit | let g' #a #b #m {| monad m |} (x : m a) =
(laws #m).idL () (fun () -> x);
(laws #m).idR x;
assert (bind #m x (return #m) == bind #m (return #m ()) (fun () -> x)) | {
"file_name": "examples/typeclasses/Monad.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 72,
"end_line": 60,
"start_col": 0,
"start_line": 57
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Functor.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Monad.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.Typeclasses",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | {| _: Monad.monad m |} -> x: m a -> Prims.unit | Prims.Tot | [
"total"
] | [] | [
"Monad.monad",
"Prims._assert",
"Prims.eq2",
"Monad.bind",
"Monad.return",
"Prims.unit",
"Monad.__proj__Mkmonad_laws__item__idR",
"Monad.__proj__Mkmonad__item__return",
"Monad.__proj__Mkmonad__item__bind",
"Monad.laws",
"Monad.__proj__Mkmonad_laws__item__idL"
] | [] | false | false | false | false | false | let g' #a #b #m {| _: monad m |} (x: m a) =
| (laws #m).idL () (fun () -> x);
(laws #m).idR x;
assert (bind #m x (return #m) == bind #m (return #m ()) (fun () -> x)) | false | |
Monad.fst | Monad.g | val g : {| d: Monad.monad m |} -> x: m a -> Prims.unit | let g #a #b #m {| d : monad m |} (x : m a) =
d.laws.idL () (fun () -> x);
d.laws.idR x;
assert (bind #m x (return #m) == bind #m (return #m ()) (fun () -> x)) | {
"file_name": "examples/typeclasses/Monad.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 72,
"end_line": 54,
"start_col": 0,
"start_line": 51
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Functor.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Monad.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.Typeclasses",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_mod... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | {| d: Monad.monad m |} -> x: m a -> Prims.unit | Prims.Tot | [
"total"
] | [] | [
"Monad.monad",
"Prims._assert",
"Prims.eq2",
"Monad.bind",
"Monad.return",
"Prims.unit",
"Monad.__proj__Mkmonad_laws__item__idR",
"Monad.__proj__Mkmonad__item__return",
"Monad.__proj__Mkmonad__item__bind",
"Monad.__proj__Mkmonad__item__laws",
"Monad.__proj__Mkmonad_laws__item__idL"
] | [] | false | false | false | false | false | let g #a #b #m {| d: monad m |} (x: m a) =
| d.laws.idL () (fun () -> x);
d.laws.idR x;
assert (bind #m x (return #m) == bind #m (return #m ()) (fun () -> x)) | false | |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_optimized_barrett_reduce2 | val lemma_optimized_barrett_reduce2:
a:nat{a < pow2 512} ->
Lemma (a - ((a * (pow2 512 / S.q)) / pow2 512) * S.q < pow2 264 /\
a - ((a * (pow2 512 / S.q)) / pow2 512) * S.q >= 0) | val lemma_optimized_barrett_reduce2:
a:nat{a < pow2 512} ->
Lemma (a - ((a * (pow2 512 / S.q)) / pow2 512) * S.q < pow2 264 /\
a - ((a * (pow2 512 / S.q)) / pow2 512) * S.q >= 0) | let lemma_optimized_barrett_reduce2 a =
assert_norm (pow2 248 = 0x100000000000000000000000000000000000000000000000000000000000000);
assert_norm (pow2 264 = 0x1000000000000000000000000000000000000000000000000000000000000000000);
assert_norm (S.q == 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 159,
"end_line": 835,
"start_col": 0,
"start_line": 831
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Prims.nat{a < Prims.pow2 512}
-> FStar.Pervasives.Lemma
(ensures
a - (a * (Prims.pow2 512 / Spec.Ed25519.q) / Prims.pow2 512) * Spec.Ed25519.q < Prims.pow2 264 /\
a - (a * (Prims.pow2 512 / Spec.Ed25519.q) / Prims.pow2 512) * Spec.Ed25519.q >= 0) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.unit",
"Spec.Ed25519.q",
"Prims.op_Equality"
] | [] | true | false | true | false | false | let lemma_optimized_barrett_reduce2 a =
| assert_norm (pow2 248 = 0x100000000000000000000000000000000000000000000000000000000000000);
assert_norm (pow2 264 = 0x1000000000000000000000000000000000000000000000000000000000000000000);
assert_norm (S.q == 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed);
assert_norm (0x1000000000000000000000000000... | false |
LowParse.Low.DER.fst | LowParse.Low.DER.jump_der_length_payload32 | val jump_der_length_payload32 (x: U8.t{der_length_payload_size_of_tag x <= 4})
: Tot (jumper (parse_der_length_payload32 x)) | val jump_der_length_payload32 (x: U8.t{der_length_payload_size_of_tag x <= 4})
: Tot (jumper (parse_der_length_payload32 x)) | let jump_der_length_payload32
(x: U8.t { der_length_payload_size_of_tag x <= 4 } )
: Tot (jumper (parse_der_length_payload32 x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_der_length_payload32 x) h input pos;
parse_der_length_payload32_unfold x (by... | {
"file_name": "src/lowparse/LowParse.Low.DER.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 44,
"end_line": 106,
"start_col": 0,
"start_line": 82
} | module LowParse.Low.DER
include LowParse.Spec.DER
include LowParse.Low.Int // for parse_u8
include LowParse.Low.BoundedInt // for bounded_integer
open FStar.Mul
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.U... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.DER.fsti.checked",
"LowParse.Low.Int.fsti.checked",
"LowParse.Low.BoundedInt.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt8.t{LowParse.Spec.DER.der_length_payload_size_of_tag x <= 4}
-> LowParse.Low.Base.jumper (LowParse.Spec.DER.parse_der_length_payload32 x) | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt8.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.DER.der_length_payload_size_of_tag",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.UInt8.lt",
"FStar.UInt8.__uint_to_t",
"Prims.bool",
"FStar.UInt32.add",
"FStar.Int.Cast... | [] | false | false | false | false | false | let jump_der_length_payload32 (x: U8.t{der_length_payload_size_of_tag x <= 4})
: Tot (jumper (parse_der_length_payload32 x)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
valid_facts (parse_der_length_payload32 x) h input pos;
parse_der_length_payload32_unfold x (bytes_of_slice_from h input pos);
assert_norm (pow2 (8 * 1) == 256);
assert_norm (pow2 (8 * 2) == 65536);
assert_norm (pow2 (8 * ... | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_div264_x8 | val lemma_div264_x8: x8:uint64 ->
Lemma (pow2 16 * (v x8 % pow2 40) * pow2 168 + v x8 / pow2 40 * pow2 224 == v x8 * pow2 184) | val lemma_div264_x8: x8:uint64 ->
Lemma (pow2 16 * (v x8 % pow2 40) * pow2 168 + v x8 / pow2 40 * pow2 224 == v x8 * pow2 184) | let lemma_div264_x8 x8 =
calc (==) {
pow2 16 * (v x8 % pow2 40) * pow2 168 + v x8 / pow2 40 * pow2 224;
(==) { _ by (Tactics.norm [delta; primops]; int_semiring ()) }
((v x8 / pow2 40) * pow2 40 + v x8 % pow2 40) * pow2 184;
(==) { Math.Lemmas.euclidean_division_definition (v x8) (pow2 40) }
v x8 ... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 405,
"start_col": 0,
"start_line": 398
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x8: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(Prims.pow2 16 * (Lib.IntTypes.v x8 % Prims.pow2 40)) * Prims.pow2 168 +
(Lib.IntTypes.v x8 / Prims.pow2 40) * Prims.pow2 224 ==
Lib.IntTypes.v x8 * Prims.pow2 184) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.uint64",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Modulus",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_Division",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"P... | [] | false | false | true | false | false | let lemma_div264_x8 x8 =
| calc ( == ) {
(pow2 16 * (v x8 % pow2 40)) * pow2 168 + (v x8 / pow2 40) * pow2 224;
( == ) { FStar.Tactics.Effect.synth_by_tactic (fun _ ->
(Tactics.norm [delta; primops];
int_semiring ())) }
((v x8 / pow2 40) * pow2 40 + v x8 % pow2 40) * pow2 184;
( == ) { Math.Lemmas.euclidean_division_def... | false |
LowParse.Low.ConstInt32.fst | LowParse.Low.ConstInt32.compare_by_bytes | val compare_by_bytes : a0: FStar.UInt8.t{0 <= FStar.UInt8.v a0 /\ FStar.UInt8.v a0 < 256} ->
a1: FStar.UInt8.t{0 <= FStar.UInt8.v a1 /\ FStar.UInt8.v a1 < 256} ->
a2: FStar.UInt8.t{0 <= FStar.UInt8.v a2 /\ FStar.UInt8.v a2 < 256} ->
a3: FStar.UInt8.t{0 <= FStar.UInt8.v a3 /\ FStar.UInt8.v a3 < 256} ->
b... | let compare_by_bytes
(a0: U8.t { 0 <= U8.v a0 /\ U8.v a0 < 256 } )
(a1: U8.t { 0 <= U8.v a1 /\ U8.v a1 < 256 } )
(a2: U8.t { 0 <= U8.v a2 /\ U8.v a2 < 256 } )
(a3: U8.t { 0 <= U8.v a3 /\ U8.v a3 < 256 } )
(b0: U8.t { 0 <= U8.v b0 /\ U8.v b0 < 256 } )
(b1: U8.t { 0 <= U8.v b1 /\ U8.v b1 < 256 } )
(b2: U8.t... | {
"file_name": "src/lowparse/LowParse.Low.ConstInt32.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 42,
"end_line": 115,
"start_col": 0,
"start_line": 106
} | module LowParse.Low.ConstInt32
(* LowParse implementation module for 32 bits contants *)
include FStar.Endianness
include LowParse.Spec.ConstInt32
include LowParse.Spec.Int32le
include LowParse.Low.Combinators
include LowParse.Low.Int32le
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStac... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Int32le.fst.checked",
"LowParse.Spec.ConstInt32.fst.checked",
"LowParse.Low.Int32le.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UIn... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a0: FStar.UInt8.t{0 <= FStar.UInt8.v a0 /\ FStar.UInt8.v a0 < 256} ->
a1: FStar.UInt8.t{0 <= FStar.UInt8.v a1 /\ FStar.UInt8.v a1 < 256} ->
a2: FStar.UInt8.t{0 <= FStar.UInt8.v a2 /\ FStar.UInt8.v a2 < 256} ->
a3: FStar.UInt8.t{0 <= FStar.UInt8.v a3 /\ FStar.UInt8.v a3 < 256} ->
b0: FStar.UInt8.t{0... | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt8.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt8.v",
"Prims.op_LessThan",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"Prims.l_or",
"Prims.bool"
] | [] | false | false | false | false | false | let compare_by_bytes
(a0: U8.t{0 <= U8.v a0 /\ U8.v a0 < 256})
(a1: U8.t{0 <= U8.v a1 /\ U8.v a1 < 256})
(a2: U8.t{0 <= U8.v a2 /\ U8.v a2 < 256})
(a3: U8.t{0 <= U8.v a3 /\ U8.v a3 < 256})
(b0: U8.t{0 <= U8.v b0 /\ U8.v b0 < 256})
(b1: U8.t{0 <= U8.v b1 /\ U8.v b1 < 256})
(b2: ... | a0 = b0 && a1 = b1 && a2 = b2 && a3 = b3 | false | |
LowParse.Low.ConstInt32.fst | LowParse.Low.ConstInt32.compose_int32le | val compose_int32le
(b0: nat{0 <= b0 /\ b0 < 256})
(b1: nat{0 <= b1 /\ b1 < 256})
(b2: nat{0 <= b2 /\ b2 < 256})
(b3: nat{0 <= b3 /\ b3 < 256})
: Tot (v: nat{0 <= v /\ v < 4294967296}) | val compose_int32le
(b0: nat{0 <= b0 /\ b0 < 256})
(b1: nat{0 <= b1 /\ b1 < 256})
(b2: nat{0 <= b2 /\ b2 < 256})
(b3: nat{0 <= b3 /\ b3 < 256})
: Tot (v: nat{0 <= v /\ v < 4294967296}) | let compose_int32le
(b0: nat { 0 <= b0 /\ b0 < 256 } )
(b1: nat { 0 <= b1 /\ b1 < 256 } )
(b2: nat { 0 <= b2 /\ b2 < 256 } )
(b3: nat { 0 <= b3 /\ b3 < 256 } )
: Tot (v: nat { 0 <= v /\ v < 4294967296 } )
= b0
+ 256 `FStar.Mul.op_Star` (b1
+ 256 `FStar.Mul.op_Star` (b2
+ 256 `FStar.Mul.op_Star` b3)) | {
"file_name": "src/lowparse/LowParse.Low.ConstInt32.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 32,
"end_line": 94,
"start_col": 0,
"start_line": 85
} | module LowParse.Low.ConstInt32
(* LowParse implementation module for 32 bits contants *)
include FStar.Endianness
include LowParse.Spec.ConstInt32
include LowParse.Spec.Int32le
include LowParse.Low.Combinators
include LowParse.Low.Int32le
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStac... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Int32le.fst.checked",
"LowParse.Spec.ConstInt32.fst.checked",
"LowParse.Low.Int32le.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UIn... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b0: Prims.nat{0 <= b0 /\ b0 < 256} ->
b1: Prims.nat{0 <= b1 /\ b1 < 256} ->
b2: Prims.nat{0 <= b2 /\ b2 < 256} ->
b3: Prims.nat{0 <= b3 /\ b3 < 256}
-> v: Prims.nat{0 <= v /\ v < 4294967296} | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.Mul.op_Star"
] | [] | false | false | false | false | false | let compose_int32le
(b0: nat{0 <= b0 /\ b0 < 256})
(b1: nat{0 <= b1 /\ b1 < 256})
(b2: nat{0 <= b2 /\ b2 < 256})
(b3: nat{0 <= b3 /\ b3 < 256})
: Tot (v: nat{0 <= v /\ v < 4294967296}) =
| b0 + 256 `FStar.Mul.op_Star` (b1 + 256 `FStar.Mul.op_Star` (b2 + 256 `FStar.Mul.op_Star` b3)) | false |
LowParse.Low.ConstInt32.fst | LowParse.Low.ConstInt32.valid_constint32le | val valid_constint32le
(v: nat{0 <= v /\ v < 4294967296})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(valid (parse_constint32le v) h input pos <==>
(valid parse_int32le h input pos /\ U32.v (contents parse_int32le h input pos) == v)) | val valid_constint32le
(v: nat{0 <= v /\ v < 4294967296})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(valid (parse_constint32le v) h input pos <==>
(valid parse_int32le h input pos /\ U32.v (contents parse_int32le h input pos) == v)) | let valid_constint32le
(v: nat { 0 <= v /\ v < 4294967296 } )
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma (valid (parse_constint32le v) h input pos
<==>
(valid parse_int32le h input pos /\
U32.v (contents parse_int32le h input pos) == v))
= valid_facts (parse_constin... | {
"file_name": "src/lowparse/LowParse.Low.ConstInt32.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 63,
"end_line": 32,
"start_col": 0,
"start_line": 20
} | module LowParse.Low.ConstInt32
(* LowParse implementation module for 32 bits contants *)
include FStar.Endianness
include LowParse.Spec.ConstInt32
include LowParse.Spec.Int32le
include LowParse.Low.Combinators
include LowParse.Low.Int32le
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStac... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Int32le.fst.checked",
"LowParse.Spec.ConstInt32.fst.checked",
"LowParse.Low.Int32le.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UIn... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
v: Prims.nat{0 <= v /\ v < 4294967296} ->
h: FStar.Monotonic.HyperStack.mem ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(ensures
LowParse.Low.Base.Spec.valid (LowParse.Spec.ConstInt32.parse_constint32le v) h input pos <==>
LowParse.Low.Base... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.ConstInt32.parse_constint32le_unfold",
"LowParse.Slice.bytes_of_sli... | [] | true | false | true | false | false | let valid_constint32le
(v: nat{0 <= v /\ v < 4294967296})
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(valid (parse_constint32le v) h input pos <==>
(valid parse_int32le h input pos /\ U32.v (contents parse_int32le h input pos) == v)) =
| valid_facts (parse_constint32le v) h input pos;
valid_facts parse_int32le h input pos;
parse_constint32le_unfold v (bytes_of_slice_from h input pos) | false |
LowParse.Low.ConstInt32.fst | LowParse.Low.ConstInt32.decompose_int32le_2 | val decompose_int32le_2 (v: nat{0 <= v /\ v < 4294967296}) : Tot (b2: nat{0 <= b2 /\ b2 < 256}) | val decompose_int32le_2 (v: nat{0 <= v /\ v < 4294967296}) : Tot (b2: nat{0 <= b2 /\ b2 < 256}) | let decompose_int32le_2
(v: nat { 0 <= v /\ v < 4294967296 } )
: Tot (b2: nat { 0 <= b2 /\ b2 < 256 } )
= v / 65536 % 256 | {
"file_name": "src/lowparse/LowParse.Low.ConstInt32.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 17,
"end_line": 77,
"start_col": 0,
"start_line": 74
} | module LowParse.Low.ConstInt32
(* LowParse implementation module for 32 bits contants *)
include FStar.Endianness
include LowParse.Spec.ConstInt32
include LowParse.Spec.Int32le
include LowParse.Low.Combinators
include LowParse.Low.Int32le
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStac... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Int32le.fst.checked",
"LowParse.Spec.ConstInt32.fst.checked",
"LowParse.Low.Int32le.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UIn... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | v: Prims.nat{0 <= v /\ v < 4294967296} -> b2: Prims.nat{0 <= b2 /\ b2 < 256} | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Modulus",
"Prims.op_Division"
] | [] | false | false | false | false | false | let decompose_int32le_2 (v: nat{0 <= v /\ v < 4294967296}) : Tot (b2: nat{0 <= b2 /\ b2 < 256}) =
| v / 65536 % 256 | false |
LowParse.Low.ConstInt32.fst | LowParse.Low.ConstInt32.decompose_int32le_3 | val decompose_int32le_3 (v: nat{0 <= v /\ v < 4294967296}) : Tot (b3: nat{0 <= b3 /\ b3 < 256}) | val decompose_int32le_3 (v: nat{0 <= v /\ v < 4294967296}) : Tot (b3: nat{0 <= b3 /\ b3 < 256}) | let decompose_int32le_3
(v: nat { 0 <= v /\ v < 4294967296 } )
: Tot (b3: nat { 0 <= b3 /\ b3 < 256 } )
= v / 16777216 | {
"file_name": "src/lowparse/LowParse.Low.ConstInt32.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 14,
"end_line": 83,
"start_col": 0,
"start_line": 80
} | module LowParse.Low.ConstInt32
(* LowParse implementation module for 32 bits contants *)
include FStar.Endianness
include LowParse.Spec.ConstInt32
include LowParse.Spec.Int32le
include LowParse.Low.Combinators
include LowParse.Low.Int32le
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStac... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Int32le.fst.checked",
"LowParse.Spec.ConstInt32.fst.checked",
"LowParse.Low.Int32le.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UIn... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | v: Prims.nat{0 <= v /\ v < 4294967296} -> b3: Prims.nat{0 <= b3 /\ b3 < 256} | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Division"
] | [] | false | false | false | false | false | let decompose_int32le_3 (v: nat{0 <= v /\ v < 4294967296}) : Tot (b3: nat{0 <= b3 /\ b3 < 256}) =
| v / 16777216 | false |
LowParse.Low.ConstInt32.fst | LowParse.Low.ConstInt32.compare_by_bytes' | val compare_by_bytes' : a0: FStar.UInt8.t{0 <= FStar.UInt8.v a0 /\ FStar.UInt8.v a0 < 256} ->
a1: FStar.UInt8.t{0 <= FStar.UInt8.v a1 /\ FStar.UInt8.v a1 < 256} ->
a2: FStar.UInt8.t{0 <= FStar.UInt8.v a2 /\ FStar.UInt8.v a2 < 256} ->
a3: FStar.UInt8.t{0 <= FStar.UInt8.v a3 /\ FStar.UInt8.v a3 < 256} ->
... | let compare_by_bytes'
(a0: U8.t { 0 <= U8.v a0 /\ U8.v a0 < 256 } )
(a1: U8.t { 0 <= U8.v a1 /\ U8.v a1 < 256 } )
(a2: U8.t { 0 <= U8.v a2 /\ U8.v a2 < 256 } )
(a3: U8.t { 0 <= U8.v a3 /\ U8.v a3 < 256 } )
(b0: U8.t { 0 <= U8.v b0 /\ U8.v b0 < 256 } )
(b1: U8.t { 0 <= U8.v b1 /\ U8.v b1 < 256 } )
(b2: U8.... | {
"file_name": "src/lowparse/LowParse.Low.ConstInt32.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 59,
"end_line": 127,
"start_col": 0,
"start_line": 117
} | module LowParse.Low.ConstInt32
(* LowParse implementation module for 32 bits contants *)
include FStar.Endianness
include LowParse.Spec.ConstInt32
include LowParse.Spec.Int32le
include LowParse.Low.Combinators
include LowParse.Low.Int32le
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStac... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Int32le.fst.checked",
"LowParse.Spec.ConstInt32.fst.checked",
"LowParse.Low.Int32le.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UIn... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a0: FStar.UInt8.t{0 <= FStar.UInt8.v a0 /\ FStar.UInt8.v a0 < 256} ->
a1: FStar.UInt8.t{0 <= FStar.UInt8.v a1 /\ FStar.UInt8.v a1 < 256} ->
a2: FStar.UInt8.t{0 <= FStar.UInt8.v a2 /\ FStar.UInt8.v a2 < 256} ->
a3: FStar.UInt8.t{0 <= FStar.UInt8.v a3 /\ FStar.UInt8.v a3 < 256} ->
b0: FStar.UInt8.t{0... | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt8.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt8.v",
"Prims.op_LessThan",
"Prims.op_Equality",
"Prims.nat",
"Prims.l_or",
"LowParse.Low.ConstInt32.compose_int32le",
"Prims.bool"
] | [] | false | false | false | false | false | let compare_by_bytes'
(a0: U8.t{0 <= U8.v a0 /\ U8.v a0 < 256})
(a1: U8.t{0 <= U8.v a1 /\ U8.v a1 < 256})
(a2: U8.t{0 <= U8.v a2 /\ U8.v a2 < 256})
(a3: U8.t{0 <= U8.v a3 /\ U8.v a3 < 256})
(b0: U8.t{0 <= U8.v b0 /\ U8.v b0 < 256})
(b1: U8.t{0 <= U8.v b1 /\ U8.v b1 < 256})
(b2:... | (compose_int32le (U8.v a0) (U8.v a1) (U8.v a2) (U8.v a3)) =
(compose_int32le (U8.v b0) (U8.v b1) (U8.v b2) (U8.v b3)) | false | |
LowParse.Low.ConstInt32.fst | LowParse.Low.ConstInt32.read_constint32le | val read_constint32le (v: U32.t{0 <= U32.v v /\ U32.v v < 4294967296})
: Tot (leaf_reader (parse_constint32le (U32.v v))) | val read_constint32le (v: U32.t{0 <= U32.v v /\ U32.v v < 4294967296})
: Tot (leaf_reader (parse_constint32le (U32.v v))) | let read_constint32le
(v: U32.t { 0 <= U32.v v /\ U32.v v < 4294967296 } )
: Tot (leaf_reader (parse_constint32le (U32.v v)))
= fun #rrel #rel input pos ->
v | {
"file_name": "src/lowparse/LowParse.Low.ConstInt32.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 59,
"start_col": 0,
"start_line": 55
} | module LowParse.Low.ConstInt32
(* LowParse implementation module for 32 bits contants *)
include FStar.Endianness
include LowParse.Spec.ConstInt32
include LowParse.Spec.Int32le
include LowParse.Low.Combinators
include LowParse.Low.Int32le
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStac... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Int32le.fst.checked",
"LowParse.Spec.ConstInt32.fst.checked",
"LowParse.Low.Int32le.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UIn... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | v: FStar.UInt32.t{0 <= FStar.UInt32.v v /\ FStar.UInt32.v v < 4294967296}
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.ConstInt32.parse_constint32le (FStar.UInt32.v v)) | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.op_LessThan",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"LowParse.Spec.ConstInt32.constint32",
"LowParse.Low.Base.leaf_reader",
"LowParse.Spec.ConstInt32.parse_constin... | [] | false | false | false | false | false | let read_constint32le (v: U32.t{0 <= U32.v v /\ U32.v v < 4294967296})
: Tot (leaf_reader (parse_constint32le (U32.v v))) =
| fun #rrel #rel input pos -> v | false |
LowParse.Low.DER.fst | LowParse.Low.DER.serialize32_bounded_der_length32 | val serialize32_bounded_der_length32
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
: Tot (serializer32 (serialize_bounded_der_length32 (vmin) (vmax))) | val serialize32_bounded_der_length32
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
: Tot (serializer32 (serialize_bounded_der_length32 (vmin) (vmax))) | let serialize32_bounded_der_length32
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
: Tot (serializer32 (serialize_bounded_der_length32 (vmin) (vmax)))
= fun (y' : bounded_int32 (vmin) (vmax)) #rrel #rel b pos ->
serialize32_bounded_der_length32' vmin vmax y' b pos | {
"file_name": "src/lowparse/LowParse.Low.DER.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 54,
"end_line": 319,
"start_col": 0,
"start_line": 314
} | module LowParse.Low.DER
include LowParse.Spec.DER
include LowParse.Low.Int // for parse_u8
include LowParse.Low.BoundedInt // for bounded_integer
open FStar.Mul
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.U... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.DER.fsti.checked",
"LowParse.Low.Int.fsti.checked",
"LowParse.Low.BoundedInt.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
vmin: LowParse.Spec.DER.der_length_t ->
vmax: LowParse.Spec.DER.der_length_t{vmin <= vmax /\ vmax < 4294967296}
-> LowParse.Low.Base.serializer32 (LowParse.Spec.DER.serialize_bounded_der_length32 vmin vmax) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.DER.der_length_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowStar.Monotonic.Buffer.srel",
"LowParse.Bytes.byte",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowParse.Low.DER.serialize32_bou... | [] | false | false | false | false | false | let serialize32_bounded_der_length32
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
: Tot (serializer32 (serialize_bounded_der_length32 (vmin) (vmax))) =
| fun (y': bounded_int32 (vmin) (vmax)) #rrel #rel b pos ->
serialize32_bounded_der_length32' vmin vmax y' b pos | false |
LowParse.Low.DER.fst | LowParse.Low.DER.read_der_length_payload32 | val read_der_length_payload32 (x: U8.t{der_length_payload_size_of_tag x <= 4})
: Tot (leaf_reader (parse_der_length_payload32 x)) | val read_der_length_payload32 (x: U8.t{der_length_payload_size_of_tag x <= 4})
: Tot (leaf_reader (parse_der_length_payload32 x)) | let read_der_length_payload32
(x: U8.t { der_length_payload_size_of_tag x <= 4 } )
: Tot (leaf_reader (parse_der_length_payload32 x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_der_length_payload32 x) h input pos;
parse_der_length_payload32_unfold ... | {
"file_name": "src/lowparse/LowParse.Low.DER.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 54,
"end_line": 151,
"start_col": 0,
"start_line": 109
} | module LowParse.Low.DER
include LowParse.Spec.DER
include LowParse.Low.Int // for parse_u8
include LowParse.Low.BoundedInt // for bounded_integer
open FStar.Mul
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.U... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.DER.fsti.checked",
"LowParse.Low.Int.fsti.checked",
"LowParse.Low.BoundedInt.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt8.t{LowParse.Spec.DER.der_length_payload_size_of_tag x <= 4}
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.DER.parse_der_length_payload32 x) | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt8.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.DER.der_length_payload_size_of_tag",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.UInt8.lt",
"FStar.UInt8.__uint_to_t",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Spe... | [] | false | false | false | false | false | let read_der_length_payload32 (x: U8.t{der_length_payload_size_of_tag x <= 4})
: Tot (leaf_reader (parse_der_length_payload32 x)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
valid_facts (parse_der_length_payload32 x) h input pos;
parse_der_length_payload32_unfold x (bytes_of_slice_from h input pos);
assert_norm (pow2 (8 * 1) == 256);
assert_norm (pow2 (8 * 2) == 65536);
assert_norm (pow2 (8 * ... | false |
LowParse.Low.DER.fst | LowParse.Low.DER.write_bounded_der_length32 | val write_bounded_der_length32
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
: Tot (leaf_writer_strong (serialize_bounded_der_length32 (vmin) (vmax))) | val write_bounded_der_length32
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
: Tot (leaf_writer_strong (serialize_bounded_der_length32 (vmin) (vmax))) | let write_bounded_der_length32
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
: Tot (leaf_writer_strong (serialize_bounded_der_length32 (vmin) (vmax)))
= leaf_writer_strong_of_serializer32 (serialize32_bounded_der_length32 vmin vmax) () | {
"file_name": "src/lowparse/LowParse.Low.DER.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 84,
"end_line": 326,
"start_col": 0,
"start_line": 322
} | module LowParse.Low.DER
include LowParse.Spec.DER
include LowParse.Low.Int // for parse_u8
include LowParse.Low.BoundedInt // for bounded_integer
open FStar.Mul
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.U... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.DER.fsti.checked",
"LowParse.Low.Int.fsti.checked",
"LowParse.Low.BoundedInt.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
vmin: LowParse.Spec.DER.der_length_t ->
vmax: LowParse.Spec.DER.der_length_t{vmin <= vmax /\ vmax < 4294967296}
-> LowParse.Low.Base.leaf_writer_strong (LowParse.Spec.DER.serialize_bounded_der_length32 vmin
vmax) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.DER.der_length_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Low.Base.leaf_writer_strong_of_serializer32",
"LowParse.Spec.DER.parse_bounded_der_length32_kind",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.DER.parse_bounded_der_l... | [] | false | false | false | false | false | let write_bounded_der_length32
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
: Tot (leaf_writer_strong (serialize_bounded_der_length32 (vmin) (vmax))) =
| leaf_writer_strong_of_serializer32 (serialize32_bounded_der_length32 vmin vmax) () | false |
Hacl.Spec.BignumQ.Lemmas.fst | Hacl.Spec.BignumQ.Lemmas.lemma_optimized_barrett_reduce | val lemma_optimized_barrett_reduce:
a:nat{a < pow2 512} ->
Lemma (a - (((a / pow2 248) * (pow2 512 / S.q)) / pow2 264) * S.q < 2 * S.q
/\ a - (((a / pow2 248) * (pow2 512 / S.q)) / pow2 264) * S.q >= 0) | val lemma_optimized_barrett_reduce:
a:nat{a < pow2 512} ->
Lemma (a - (((a / pow2 248) * (pow2 512 / S.q)) / pow2 264) * S.q < 2 * S.q
/\ a - (((a / pow2 248) * (pow2 512 / S.q)) / pow2 264) * S.q >= 0) | let lemma_optimized_barrett_reduce a =
assert_norm (pow2 248 = 0x100000000000000000000000000000000000000000000000000000000000000);
assert_norm (pow2 264 = 0x1000000000000000000000000000000000000000000000000000000000000000000);
assert_norm (S.q == 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed)... | {
"file_name": "code/ed25519/Hacl.Spec.BignumQ.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 159,
"end_line": 821,
"start_col": 0,
"start_line": 817
} | module Hacl.Spec.BignumQ.Lemmas
open FStar.Tactics.CanonCommSemiring
open FStar.Mul
open Lib.IntTypes
module S = Spec.Ed25519
include Hacl.Spec.BignumQ.Definitions
let feq (#a #b:Type) (f:(a -> b)) (x y:a) :
Lemma (requires x == y) (ensures f x == f y) = ()
let eq_eq2 (#a:eqtype) (x y:a) :
Lemma (requires x = ... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Prims.nat{a < Prims.pow2 512}
-> FStar.Pervasives.Lemma
(ensures
a -
((a / Prims.pow2 248) * (Prims.pow2 512 / Spec.Ed25519.q) / Prims.pow2 264) * Spec.Ed25519.q <
2 * Spec.Ed25519.q /\
a -
((a / Prims.pow2 248) * (Prims.pow2 512 / Spec.Ed25519.q) / Prims.pow2 264) * Spec.Ed25519.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.unit",
"Spec.Ed25519.q",
"Prims.op_Equality"
] | [] | true | false | true | false | false | let lemma_optimized_barrett_reduce a =
| assert_norm (pow2 248 = 0x100000000000000000000000000000000000000000000000000000000000000);
assert_norm (pow2 264 = 0x1000000000000000000000000000000000000000000000000000000000000000000);
assert_norm (S.q == 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed);
assert_norm (0x1000000000000000000000000000... | false |
LowParse.Low.DER.fst | LowParse.Low.DER.validate_der_length_payload32 | val validate_der_length_payload32 (x: U8.t{der_length_payload_size_of_tag x <= 4})
: Tot (validator (parse_der_length_payload32 x)) | val validate_der_length_payload32 (x: U8.t{der_length_payload_size_of_tag x <= 4})
: Tot (validator (parse_der_length_payload32 x)) | let validate_der_length_payload32
(x: U8.t { der_length_payload_size_of_tag x <= 4 } )
: Tot (validator (parse_der_length_payload32 x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
valid_facts (parse_der_length_payload32 x) h input (uint64_to_uint32 pos);
assert (U64.v... | {
"file_name": "src/lowparse/LowParse.Low.DER.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 16,
"end_line": 79,
"start_col": 0,
"start_line": 19
} | module LowParse.Low.DER
include LowParse.Spec.DER
include LowParse.Low.Int // for parse_u8
include LowParse.Low.BoundedInt // for bounded_integer
open FStar.Mul
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.U... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.DER.fsti.checked",
"LowParse.Low.Int.fsti.checked",
"LowParse.Low.BoundedInt.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt8.t{LowParse.Spec.DER.der_length_payload_size_of_tag x <= 4}
-> LowParse.Low.Base.validator (LowParse.Spec.DER.parse_der_length_payload32 x) | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt8.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Spec.DER.der_length_payload_size_of_tag",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"FStar.UInt8.lt",
"FStar.UInt8.__uint_to_t",
"Prims.bool",
"Prims.op_BarBar",
"Prims.op_Equali... | [] | false | false | false | false | false | let validate_der_length_payload32 (x: U8.t{der_length_payload_size_of_tag x <= 4})
: Tot (validator (parse_der_length_payload32 x)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
valid_facts (parse_der_length_payload32 x) h input (uint64_to_uint32 pos);
assert (U64.v pos <= U32.v input.len);
parse_der_length_payload32_unfold x (bytes_of_slice_from h input (uint64_to_uint32 pos));
assert_norm (pow2 (8 *... | false |
LowParse.Low.DER.fst | LowParse.Low.DER.read_bounded_der_length32 | val read_bounded_der_length32
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
: Tot (leaf_reader (parse_bounded_der_length32 (vmin) (vmax))) | val read_bounded_der_length32
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
: Tot (leaf_reader (parse_bounded_der_length32 (vmin) (vmax))) | let read_bounded_der_length32
(vmin: der_length_t)
(vmax: der_length_t { vmin <= vmax /\ vmax < 4294967296 } )
: Tot (
leaf_reader (parse_bounded_der_length32 (vmin) (vmax)))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_bounded_der_length32 (vmin) ... | {
"file_name": "src/lowparse/LowParse.Low.DER.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 38,
"end_line": 231,
"start_col": 0,
"start_line": 213
} | module LowParse.Low.DER
include LowParse.Spec.DER
include LowParse.Low.Int // for parse_u8
include LowParse.Low.BoundedInt // for bounded_integer
open FStar.Mul
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.U... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.DER.fsti.checked",
"LowParse.Low.Int.fsti.checked",
"LowParse.Low.BoundedInt.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
vmin: LowParse.Spec.DER.der_length_t ->
vmax: LowParse.Spec.DER.der_length_t{vmin <= vmax /\ vmax < 4294967296}
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.DER.parse_bounded_der_length32 vmin vmax) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.DER.der_length_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.BoundedInt.bounded_int32",
"LowParse.Spec.Base.refine_with_tag",
"FStar.UInt8.t"... | [] | false | false | false | false | false | let read_bounded_der_length32
(vmin: der_length_t)
(vmax: der_length_t{vmin <= vmax /\ vmax < 4294967296})
: Tot (leaf_reader (parse_bounded_der_length32 (vmin) (vmax))) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
valid_facts (parse_bounded_der_length32 (vmin) (vmax)) h input pos;
parse_bounded_der_length32_unfold (vmin) (vmax) (bytes_of_slice_from h input pos);
valid_facts parse_u8 h input pos
in
let v = jump_u8 input pos in
let x = ... | false |
LowParse.Low.ConstInt32.fst | LowParse.Low.ConstInt32.decompose_compare | val decompose_compare (v1: nat{0 <= v1 /\ v1 < 4294967296}) (v2: nat{0 <= v2 /\ v2 < 4294967296})
: Lemma
((v1 = v2) ==
(compare_by_bytes (U8.uint_to_t (decompose_int32le_0 v1))
(U8.uint_to_t (decompose_int32le_1 v1))
(U8.uint_to_t (decompose_int32le_2 v1))
(U8.uint_to_t (dec... | val decompose_compare (v1: nat{0 <= v1 /\ v1 < 4294967296}) (v2: nat{0 <= v2 /\ v2 < 4294967296})
: Lemma
((v1 = v2) ==
(compare_by_bytes (U8.uint_to_t (decompose_int32le_0 v1))
(U8.uint_to_t (decompose_int32le_1 v1))
(U8.uint_to_t (decompose_int32le_2 v1))
(U8.uint_to_t (dec... | let decompose_compare
(v1 : nat { 0 <= v1 /\ v1 < 4294967296 } )
(v2 : nat { 0 <= v2 /\ v2 < 4294967296 } )
: Lemma ( (v1 = v2)
== (compare_by_bytes
(U8.uint_to_t (decompose_int32le_0 v1))
(U8.uint_to_t (decompose_int32le_1 v1))
(U8.uint_to_t (decompose_int32le_2 v1))
(U8.uint_to_t (dec... | {
"file_name": "src/lowparse/LowParse.Low.ConstInt32.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 28,
"end_line": 173,
"start_col": 0,
"start_line": 150
} | module LowParse.Low.ConstInt32
(* LowParse implementation module for 32 bits contants *)
include FStar.Endianness
include LowParse.Spec.ConstInt32
include LowParse.Spec.Int32le
include LowParse.Low.Combinators
include LowParse.Low.Int32le
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStac... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Int32le.fst.checked",
"LowParse.Spec.ConstInt32.fst.checked",
"LowParse.Low.Int32le.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UIn... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | v1: Prims.nat{0 <= v1 /\ v1 < 4294967296} -> v2: Prims.nat{0 <= v2 /\ v2 < 4294967296}
-> FStar.Pervasives.Lemma
(ensures
v1 = v2 ==
LowParse.Low.ConstInt32.compare_by_bytes (FStar.UInt8.uint_to_t (LowParse.Low.ConstInt32.decompose_int32le_0
v1))
(FStar.UInt8.uint_to_t (LowPars... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.Low.ConstInt32.decompose_compose_equiv",
"Prims.unit",
"LowParse.Low.ConstInt32.compare_by_bytes_equiv",
"FStar.UInt8.t",
"FStar.UInt8.uint_to_t",
"LowParse.Low.ConstInt32.decompose_int32le_3",
... | [] | true | false | true | false | false | let decompose_compare (v1: nat{0 <= v1 /\ v1 < 4294967296}) (v2: nat{0 <= v2 /\ v2 < 4294967296})
: Lemma
((v1 = v2) ==
(compare_by_bytes (U8.uint_to_t (decompose_int32le_0 v1))
(U8.uint_to_t (decompose_int32le_1 v1))
(U8.uint_to_t (decompose_int32le_2 v1))
(U8.uint_to_t (dec... | let a0 = U8.uint_to_t (decompose_int32le_0 v1) in
let a1 = U8.uint_to_t (decompose_int32le_1 v1) in
let a2 = U8.uint_to_t (decompose_int32le_2 v1) in
let a3 = U8.uint_to_t (decompose_int32le_3 v1) in
let b0 = U8.uint_to_t (decompose_int32le_0 v2) in
let b1 = U8.uint_to_t (decompose_int32le_1 v2) in
let b2 = U8.uint_to_... | false |
Steel.ST.C.Types.Base.fsti | Steel.ST.C.Types.Base.ref_of_void_ptr | val ref_of_void_ptr
(#t: Type)
(#opened: _)
(#td: typedef t)
(#v: Ghost.erased t)
(x: void_ptr)
(y': Ghost.erased (ref td))
: STAtomicBase (ref td)
false
opened
Unobservable
(pts_to y' v)
(fun y -> pts_to y v)
(Ghost.reveal y' == ghost_ptr_gen_... | val ref_of_void_ptr
(#t: Type)
(#opened: _)
(#td: typedef t)
(#v: Ghost.erased t)
(x: void_ptr)
(y': Ghost.erased (ref td))
: STAtomicBase (ref td)
false
opened
Unobservable
(pts_to y' v)
(fun y -> pts_to y v)
(Ghost.reveal y' == ghost_ptr_gen_... | let ref_of_void_ptr (#t: Type) (#opened: _) (#td: typedef t) (#v: Ghost.erased t) (x: void_ptr) (y': Ghost.erased (ref td)) : STAtomicBase (ref td) false opened Unobservable
(pts_to y' v)
(fun y -> pts_to y v)
(Ghost.reveal y' == ghost_ptr_gen_of_void_ptr x t)
(fun y -> y == Ghost.reveal y')
= rewrite (pts_to y... | {
"file_name": "lib/steel/c/Steel.ST.C.Types.Base.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 10,
"end_line": 184,
"start_col": 0,
"start_line": 176
} | module Steel.ST.C.Types.Base
open Steel.ST.Util
module P = Steel.FractionalPermission
/// Helper to compose two permissions into one
val prod_perm (p1 p2: P.perm) : Pure P.perm
(requires True)
(ensures (fun p ->
((p1 `P.lesser_equal_perm` P.full_perm /\ p2 `P.lesser_equal_perm` P.full_perm) ==>
p `P.lesse... | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": ... | [
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.C.Types",
"short_module": null
},
{
"abbrev": false,
"f... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Steel.ST.C.Types.Base.void_ptr -> y': FStar.Ghost.erased (Steel.ST.C.Types.Base.ref td)
-> Steel.ST.Effect.Atomic.STAtomicBase (Steel.ST.C.Types.Base.ref td) | Steel.ST.Effect.Atomic.STAtomicBase | [] | [] | [
"Steel.Memory.inames",
"Steel.ST.C.Types.Base.typedef",
"FStar.Ghost.erased",
"Steel.ST.C.Types.Base.void_ptr",
"Steel.ST.C.Types.Base.ref",
"Steel.ST.Util.return",
"Steel.ST.C.Types.Base.pts_to",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.ST.Util.rewrite",
"Steel.ST.C.Types.Base.pts_to_o... | [] | false | true | false | false | false | let ref_of_void_ptr
(#t: Type)
(#opened: _)
(#td: typedef t)
(#v: Ghost.erased t)
(x: void_ptr)
(y': Ghost.erased (ref td))
: STAtomicBase (ref td)
false
opened
Unobservable
(pts_to y' v)
(fun y -> pts_to y v)
(Ghost.reveal y' == ghost_ptr_gen_... | rewrite (pts_to y' v) (pts_to_or_null (ghost_ptr_gen_of_void_ptr x t <: ptr td) v);
let y = ptr_of_void_ptr x in
rewrite (pts_to_or_null y v) (pts_to y v);
return y | false |
Spec.FFDHE.fst | Spec.FFDHE.list_ffdhe_g2 | val list_ffdhe_g2:List.Tot.llist pub_uint8 1 | val list_ffdhe_g2:List.Tot.llist pub_uint8 1 | let list_ffdhe_g2: List.Tot.llist pub_uint8 1 =
[@inline_let]
let l = [ 0x02uy ] in
assert_norm (List.Tot.length l == 1);
l | {
"file_name": "specs/Spec.FFDHE.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 28,
"start_col": 0,
"start_line": 24
} | module Spec.FFDHE
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https://tools.ietf.org/html/rfc7919#appendix-A *)
noeq type ffdhe_params_t =
| Mk_ffdhe_params:
ffdhe_p_len:size_nat
-> ffdhe_p:lseq pub_uint8 ffdhe_p_len
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst... | [
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | FStar.List.Tot.Properties.llist (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.PUB) 1 | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.PUB",
"Prims.list",
"Prims.Cons",
"FStar.UInt8.__uint_to_t",
"Prims.Nil"
] | [] | false | false | false | false | false | let list_ffdhe_g2:List.Tot.llist pub_uint8 1 =
| [@@ inline_let ]let l = [0x02uy] in
assert_norm (List.Tot.length l == 1);
l | false |
Spec.FFDHE.fst | Spec.FFDHE.ffdhe_params_4096 | val ffdhe_params_4096:ffdhe_params_t | val ffdhe_params_4096:ffdhe_params_t | let ffdhe_params_4096 : ffdhe_params_t =
Mk_ffdhe_params 512 ffdhe_p4096 1 ffdhe_g2 | {
"file_name": "specs/Spec.FFDHE.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 44,
"end_line": 222,
"start_col": 0,
"start_line": 221
} | module Spec.FFDHE
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https://tools.ietf.org/html/rfc7919#appendix-A *)
noeq type ffdhe_params_t =
| Mk_ffdhe_params:
ffdhe_p_len:size_nat
-> ffdhe_p:lseq pub_uint8 ffdhe_p_len
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst... | [
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Spec.FFDHE.ffdhe_params_t | Prims.Tot | [
"total"
] | [] | [
"Spec.FFDHE.Mk_ffdhe_params",
"Spec.FFDHE.ffdhe_p4096",
"Spec.FFDHE.ffdhe_g2"
] | [] | false | false | false | true | false | let ffdhe_params_4096:ffdhe_params_t =
| Mk_ffdhe_params 512 ffdhe_p4096 1 ffdhe_g2 | false |
LowParse.Low.ConstInt32.fst | LowParse.Low.ConstInt32.validate_constint32le_slow | val validate_constint32le_slow (v: U32.t{0 <= U32.v v /\ U32.v v < 4294967296})
: Tot (validator (parse_constint32le (U32.v v))) | val validate_constint32le_slow (v: U32.t{0 <= U32.v v /\ U32.v v < 4294967296})
: Tot (validator (parse_constint32le (U32.v v))) | let validate_constint32le_slow
(v: U32.t { 0 <= U32.v v /\ U32.v v < 4294967296 } )
: Tot (validator (parse_constint32le (U32.v v)))
= fun #rrel #rel (input: slice rrel rel) pos ->
let h = HST.get() in
let _ =
valid_constint32le (U32.v v) h input (uint64_to_uint32 pos);
valid_equiv parse_int32le... | {
"file_name": "src/lowparse/LowParse.Low.ConstInt32.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 29,
"end_line": 52,
"start_col": 0,
"start_line": 35
} | module LowParse.Low.ConstInt32
(* LowParse implementation module for 32 bits contants *)
include FStar.Endianness
include LowParse.Spec.ConstInt32
include LowParse.Spec.Int32le
include LowParse.Low.Combinators
include LowParse.Low.Int32le
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStac... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Int32le.fst.checked",
"LowParse.Spec.ConstInt32.fst.checked",
"LowParse.Low.Int32le.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UIn... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | v: FStar.UInt32.t{0 <= FStar.UInt32.v v /\ FStar.UInt32.v v < 4294967296}
-> LowParse.Low.Base.validator (LowParse.Spec.ConstInt32.parse_constint32le (FStar.UInt32.v v)) | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.op_LessThan",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"FStar.UInt64.lt",
"FStar.UInt64.sub",
"FStar.Int.Cast.uint32_to_uint64",
"LowParse.Slice... | [] | false | false | false | false | false | let validate_constint32le_slow (v: U32.t{0 <= U32.v v /\ U32.v v < 4294967296})
: Tot (validator (parse_constint32le (U32.v v))) =
| fun #rrel #rel (input: slice rrel rel) pos ->
let h = HST.get () in
let _ =
valid_constint32le (U32.v v) h input (uint64_to_uint32 pos);
valid_equiv parse_int32le h input (uint64_to_uint32 pos)
in
if U64.lt ((Cast.uint32_to_uint64 input.len) `U64.sub` pos) 4uL
then validator_error_not_enough_data
el... | false |
Spec.FFDHE.fst | Spec.FFDHE.ffdhe_params_2048 | val ffdhe_params_2048:ffdhe_params_t | val ffdhe_params_2048:ffdhe_params_t | let ffdhe_params_2048 : ffdhe_params_t =
Mk_ffdhe_params 256 ffdhe_p2048 1 ffdhe_g2 | {
"file_name": "specs/Spec.FFDHE.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 44,
"end_line": 78,
"start_col": 0,
"start_line": 77
} | module Spec.FFDHE
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https://tools.ietf.org/html/rfc7919#appendix-A *)
noeq type ffdhe_params_t =
| Mk_ffdhe_params:
ffdhe_p_len:size_nat
-> ffdhe_p:lseq pub_uint8 ffdhe_p_len
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst... | [
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Spec.FFDHE.ffdhe_params_t | Prims.Tot | [
"total"
] | [] | [
"Spec.FFDHE.Mk_ffdhe_params",
"Spec.FFDHE.ffdhe_p2048",
"Spec.FFDHE.ffdhe_g2"
] | [] | false | false | false | true | false | let ffdhe_params_2048:ffdhe_params_t =
| Mk_ffdhe_params 256 ffdhe_p2048 1 ffdhe_g2 | false |
Spec.FFDHE.fst | Spec.FFDHE.ffdhe_params_6144 | val ffdhe_params_6144:ffdhe_params_t | val ffdhe_params_6144:ffdhe_params_t | let ffdhe_params_6144 : ffdhe_params_t =
Mk_ffdhe_params 768 ffdhe_p6144 1 ffdhe_g2 | {
"file_name": "specs/Spec.FFDHE.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 44,
"end_line": 334,
"start_col": 0,
"start_line": 333
} | module Spec.FFDHE
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https://tools.ietf.org/html/rfc7919#appendix-A *)
noeq type ffdhe_params_t =
| Mk_ffdhe_params:
ffdhe_p_len:size_nat
-> ffdhe_p:lseq pub_uint8 ffdhe_p_len
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst... | [
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Spec.FFDHE.ffdhe_params_t | Prims.Tot | [
"total"
] | [] | [
"Spec.FFDHE.Mk_ffdhe_params",
"Spec.FFDHE.ffdhe_p6144",
"Spec.FFDHE.ffdhe_g2"
] | [] | false | false | false | true | false | let ffdhe_params_6144:ffdhe_params_t =
| Mk_ffdhe_params 768 ffdhe_p6144 1 ffdhe_g2 | false |
Spec.FFDHE.fst | Spec.FFDHE.ffdhe_g2 | val ffdhe_g2:lseq pub_uint8 1 | val ffdhe_g2:lseq pub_uint8 1 | let ffdhe_g2: lseq pub_uint8 1 = of_list list_ffdhe_g2 | {
"file_name": "specs/Spec.FFDHE.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 30,
"start_col": 0,
"start_line": 30
} | module Spec.FFDHE
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https://tools.ietf.org/html/rfc7919#appendix-A *)
noeq type ffdhe_params_t =
| Mk_ffdhe_params:
ffdhe_p_len:size_nat
-> ffdhe_p:lseq pub_uint8 ffdhe_p_len
... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst... | [
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 Lib.IntTypes.PUB) 1 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.of_list",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.PUB",
"Spec.FFDHE.list_ffdhe_g2"
] | [] | false | false | false | false | false | let ffdhe_g2:lseq pub_uint8 1 =
| of_list list_ffdhe_g2 | false |
LowParse.Low.ConstInt32.fst | LowParse.Low.ConstInt32.compare_by_bytes_equiv | val compare_by_bytes_equiv
(a0: U8.t{0 <= U8.v a0 /\ U8.v a0 < 256})
(a1: U8.t{0 <= U8.v a1 /\ U8.v a1 < 256})
(a2: U8.t{0 <= U8.v a2 /\ U8.v a2 < 256})
(a3: U8.t{0 <= U8.v a3 /\ U8.v a3 < 256})
(b0: U8.t{0 <= U8.v b0 /\ U8.v b0 < 256})
(b1: U8.t{0 <= U8.v b1 /\ U8.v b1 < 256})
... | val compare_by_bytes_equiv
(a0: U8.t{0 <= U8.v a0 /\ U8.v a0 < 256})
(a1: U8.t{0 <= U8.v a1 /\ U8.v a1 < 256})
(a2: U8.t{0 <= U8.v a2 /\ U8.v a2 < 256})
(a3: U8.t{0 <= U8.v a3 /\ U8.v a3 < 256})
(b0: U8.t{0 <= U8.v b0 /\ U8.v b0 < 256})
(b1: U8.t{0 <= U8.v b1 /\ U8.v b1 < 256})
... | let compare_by_bytes_equiv
(a0: U8.t { 0 <= U8.v a0 /\ U8.v a0 < 256 } )
(a1: U8.t { 0 <= U8.v a1 /\ U8.v a1 < 256 } )
(a2: U8.t { 0 <= U8.v a2 /\ U8.v a2 < 256 } )
(a3: U8.t { 0 <= U8.v a3 /\ U8.v a3 < 256 } )
(b0: U8.t { 0 <= U8.v b0 /\ U8.v b0 < 256 } )
(b1: U8.t { 0 <= U8.v b1 /\ U8.v b1 < 256 } )
(b2... | {
"file_name": "src/lowparse/LowParse.Low.ConstInt32.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 146,
"start_col": 0,
"start_line": 131
} | module LowParse.Low.ConstInt32
(* LowParse implementation module for 32 bits contants *)
include FStar.Endianness
include LowParse.Spec.ConstInt32
include LowParse.Spec.Int32le
include LowParse.Low.Combinators
include LowParse.Low.Int32le
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStac... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Int32le.fst.checked",
"LowParse.Spec.ConstInt32.fst.checked",
"LowParse.Low.Int32le.fst.checked",
"LowParse.Low.Combinators.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UIn... | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "F... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 5,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a0: FStar.UInt8.t{0 <= FStar.UInt8.v a0 /\ FStar.UInt8.v a0 < 256} ->
a1: FStar.UInt8.t{0 <= FStar.UInt8.v a1 /\ FStar.UInt8.v a1 < 256} ->
a2: FStar.UInt8.t{0 <= FStar.UInt8.v a2 /\ FStar.UInt8.v a2 < 256} ->
a3: FStar.UInt8.t{0 <= FStar.UInt8.v a3 /\ FStar.UInt8.v a3 < 256} ->
b0: FStar.UInt8.t{0... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt8.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt8.v",
"Prims.op_LessThan",
"LowParse.Low.ConstInt32.decompose_compose_equiv",
"Prims.unit",
"Prims.nat",
"LowParse.Low.ConstInt32.compose_int32le",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.bool",... | [] | true | false | true | false | false | let compare_by_bytes_equiv
(a0: U8.t{0 <= U8.v a0 /\ U8.v a0 < 256})
(a1: U8.t{0 <= U8.v a1 /\ U8.v a1 < 256})
(a2: U8.t{0 <= U8.v a2 /\ U8.v a2 < 256})
(a3: U8.t{0 <= U8.v a3 /\ U8.v a3 < 256})
(b0: U8.t{0 <= U8.v b0 /\ U8.v b0 < 256})
(b1: U8.t{0 <= U8.v b1 /\ U8.v b1 < 256})
... | let a = compose_int32le (U8.v a0) (U8.v a1) (U8.v a2) (U8.v a3) in
let b = compose_int32le (U8.v b0) (U8.v b1) (U8.v b2) (U8.v b3) in
decompose_compose_equiv a;
decompose_compose_equiv b | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.