effect stringclasses 48
values | original_source_type stringlengths 0 23k | opens_and_abbrevs listlengths 2 92 | isa_cross_project_example bool 1
class | source_definition stringlengths 9 57.9k | partial_definition stringlengths 7 23.3k | is_div bool 2
classes | is_type null | is_proof bool 2
classes | completed_definiton stringlengths 1 250k | dependencies dict | effect_flags listlengths 0 2 | ideal_premises listlengths 0 236 | mutual_with listlengths 0 11 | file_context stringlengths 0 407k | interleaved bool 1
class | is_simply_typed bool 2
classes | file_name stringlengths 5 48 | vconfig dict | is_simple_lemma null | source_type stringlengths 10 23k | proof_features listlengths 0 1 | name stringlengths 8 95 | source dict | verbose_type stringlengths 1 7.42k | source_range dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let op_Less_Less_Hat = shift_left | let op_Less_Less_Hat = | false | null | false | shift_left | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [] | [
"FStar.UInt64.shift_left"
] | [] | (*
Copyright 2008-2019 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... | false | false | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Less_Less_Hat : a: FStar.UInt64.t -> s: FStar.UInt32.t -> Prims.Pure FStar.UInt64.t | [] | FStar.UInt64.op_Less_Less_Hat | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> s: FStar.UInt32.t -> Prims.Pure FStar.UInt64.t | {
"end_col": 40,
"end_line": 329,
"start_col": 30,
"start_line": 329
} | |
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let op_Percent_Hat = rem | let op_Percent_Hat = | false | null | false | rem | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [] | [
"FStar.UInt64.rem"
] | [] | (*
Copyright 2008-2019 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... | false | false | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Percent_Hat : a: FStar.UInt64.t -> b: FStar.UInt64.t{FStar.UInt64.v b <> 0} -> Prims.Pure FStar.UInt64.t | [] | FStar.UInt64.op_Percent_Hat | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> b: FStar.UInt64.t{FStar.UInt64.v b <> 0} -> Prims.Pure FStar.UInt64.t | {
"end_col": 31,
"end_line": 325,
"start_col": 28,
"start_line": 325
} | |
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let op_Plus_Question_Hat = add_underspec | let op_Plus_Question_Hat = | false | null | false | add_underspec | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [] | [
"FStar.UInt64.add_underspec"
] | [] | (*
Copyright 2008-2019 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... | false | false | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Plus_Question_Hat : a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.Pure FStar.UInt64.t | [] | FStar.UInt64.op_Plus_Question_Hat | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.Pure FStar.UInt64.t | {
"end_col": 47,
"end_line": 316,
"start_col": 34,
"start_line": 316
} | |
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let op_Star_Percent_Hat = mul_mod | let op_Star_Percent_Hat = | false | null | false | mul_mod | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [] | [
"FStar.UInt64.mul_mod"
] | [] | (*
Copyright 2008-2019 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... | false | false | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Star_Percent_Hat : a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.Pure FStar.UInt64.t | [] | FStar.UInt64.op_Star_Percent_Hat | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.Pure FStar.UInt64.t | {
"end_col": 40,
"end_line": 323,
"start_col": 33,
"start_line": 323
} | |
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let op_Slash_Hat = div | let op_Slash_Hat = | false | null | false | div | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [] | [
"FStar.UInt64.div"
] | [] | (*
Copyright 2008-2019 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... | false | false | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Slash_Hat : a: FStar.UInt64.t -> b: FStar.UInt64.t{FStar.UInt64.v b <> 0} -> Prims.Pure FStar.UInt64.t | [] | FStar.UInt64.op_Slash_Hat | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> b: FStar.UInt64.t{FStar.UInt64.v b <> 0} -> Prims.Pure FStar.UInt64.t | {
"end_col": 29,
"end_line": 324,
"start_col": 26,
"start_line": 324
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let op_Less_Equals_Hat = lte | let op_Less_Equals_Hat = | false | null | false | lte | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [
"total"
] | [
"FStar.UInt64.lte"
] | [] | (*
Copyright 2008-2019 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... | false | true | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Less_Equals_Hat : a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.bool | [] | FStar.UInt64.op_Less_Equals_Hat | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.bool | {
"end_col": 35,
"end_line": 335,
"start_col": 32,
"start_line": 335
} | |
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let op_Plus_Hat = add | let op_Plus_Hat = | false | null | false | add | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [] | [
"FStar.UInt64.add"
] | [] | (*
Copyright 2008-2019 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... | false | false | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Plus_Hat : a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.Pure FStar.UInt64.t | [] | FStar.UInt64.op_Plus_Hat | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.Pure FStar.UInt64.t | {
"end_col": 28,
"end_line": 315,
"start_col": 25,
"start_line": 315
} | |
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let op_Star_Hat = mul | let op_Star_Hat = | false | null | false | mul | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [] | [
"FStar.UInt64.mul"
] | [] | (*
Copyright 2008-2019 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... | false | false | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Star_Hat : a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.Pure FStar.UInt64.t | [] | FStar.UInt64.op_Star_Hat | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.Pure FStar.UInt64.t | {
"end_col": 28,
"end_line": 321,
"start_col": 25,
"start_line": 321
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let op_Greater_Equals_Hat = gte | let op_Greater_Equals_Hat = | false | null | false | gte | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [
"total"
] | [
"FStar.UInt64.gte"
] | [] | (*
Copyright 2008-2019 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... | false | true | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Greater_Equals_Hat : a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.bool | [] | FStar.UInt64.op_Greater_Equals_Hat | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.bool | {
"end_col": 38,
"end_line": 333,
"start_col": 35,
"start_line": 333
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let op_Equals_Hat = eq | let op_Equals_Hat = | false | null | false | eq | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [
"total"
] | [
"FStar.UInt64.eq"
] | [] | (*
Copyright 2008-2019 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... | false | true | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Equals_Hat : a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.bool | [] | FStar.UInt64.op_Equals_Hat | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.bool | {
"end_col": 29,
"end_line": 331,
"start_col": 27,
"start_line": 331
} | |
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let op_Greater_Greater_Hat = shift_right | let op_Greater_Greater_Hat = | false | null | false | shift_right | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [] | [
"FStar.UInt64.shift_right"
] | [] | (*
Copyright 2008-2019 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... | false | false | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Greater_Greater_Hat : a: FStar.UInt64.t -> s: FStar.UInt32.t -> Prims.Pure FStar.UInt64.t | [] | FStar.UInt64.op_Greater_Greater_Hat | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> s: FStar.UInt32.t -> Prims.Pure FStar.UInt64.t | {
"end_col": 47,
"end_line": 330,
"start_col": 36,
"start_line": 330
} | |
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let op_Amp_Hat = logand | let op_Amp_Hat = | false | null | false | logand | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [] | [
"FStar.UInt64.logand"
] | [] | (*
Copyright 2008-2019 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... | false | false | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val op_Amp_Hat : x: FStar.UInt64.t -> y: FStar.UInt64.t -> Prims.Pure FStar.UInt64.t | [] | FStar.UInt64.op_Amp_Hat | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: FStar.UInt64.t -> y: FStar.UInt64.t -> Prims.Pure FStar.UInt64.t | {
"end_col": 30,
"end_line": 327,
"start_col": 24,
"start_line": 327
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let minus (a:t) = add_mod (lognot a) (uint_to_t 1) | let minus (a: t) = | false | null | false | add_mod (lognot a) (uint_to_t 1) | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [
"total"
] | [
"FStar.UInt64.t",
"FStar.UInt64.add_mod",
"FStar.UInt64.lognot",
"FStar.UInt64.uint_to_t"
] | [] | (*
Copyright 2008-2019 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... | false | true | FStar.UInt64.fsti | {
"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... | null | val minus : a: FStar.UInt64.t -> FStar.UInt64.t | [] | FStar.UInt64.minus | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> FStar.UInt64.t | {
"end_col": 50,
"end_line": 239,
"start_col": 18,
"start_line": 239
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let n_minus_one = UInt32.uint_to_t (n - 1) | let n_minus_one = | false | null | false | UInt32.uint_to_t (n - 1) | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [
"total"
] | [
"FStar.UInt32.uint_to_t",
"Prims.op_Subtraction",
"FStar.UInt64.n"
] | [] | (*
Copyright 2008-2019 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... | false | true | FStar.UInt64.fsti | {
"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... | null | val n_minus_one : FStar.UInt32.t | [] | FStar.UInt64.n_minus_one | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.UInt32.t | {
"end_col": 42,
"end_line": 243,
"start_col": 18,
"start_line": 243
} | |
Prims.Pure | val gte_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a >= v b ==> v c = pow2 n - 1) /\ (v a < v b ==> v c = 0))) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let gte_mask (a:t) (b:t)
: Pure t
(requires True)
(ensures (fun c -> (v a >= v b ==> v c = pow2 n - 1) /\
(v a < v b ==> v c = 0)))
= let x = a in
let y = b in
let x_xor_y = logxor x y in
let x_sub_y = sub_mod x y in
let x_sub_y_xor_y = logxor x_sub_y y in
let q = ... | val gte_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a >= v b ==> v c = pow2 n - 1) /\ (v a < v b ==> v c = 0)))
let gte_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a >= v b ==> v c = pow2 n - 1) /\ (v a < v b ==> v c = 0))) = | false | null | false | let x = a in
let y = b in
let x_xor_y = logxor x y in
let x_sub_y = sub_mod x y in
let x_sub_y_xor_y = logxor x_sub_y y in
let q = logor x_xor_y x_sub_y_xor_y in
let x_xor_q = logxor x q in
let x_xor_q_ = shift_right x_xor_q n_minus_one in
let c = sub_mod x_xor_q_ (uint_to_t 1) in
lemma_sub_msbs x y;
lemma_msb_gte (v x... | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [] | [
"FStar.UInt64.t",
"Prims.unit",
"FStar.UInt.lemma_msb_gte",
"FStar.UInt64.n",
"FStar.UInt64.v",
"FStar.UInt64.lemma_sub_msbs",
"FStar.UInt64.sub_mod",
"FStar.UInt64.uint_to_t",
"FStar.UInt64.shift_right",
"FStar.UInt64.n_minus_one",
"FStar.UInt64.logxor",
"FStar.UInt64.logor",
"Prims.l_True"... | [] | (*
Copyright 2008-2019 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... | false | false | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val gte_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a >= v b ==> v c = pow2 n - 1) /\ (v a < v b ==> v c = 0))) | [] | FStar.UInt64.gte_mask | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.Pure FStar.UInt64.t | {
"end_col": 5,
"end_line": 311,
"start_col": 3,
"start_line": 299
} |
Prims.Pure | val eq_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a = v b ==> v c = pow2 n - 1) /\ (v a <> v b ==> v c = 0))) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"sh... | false | let eq_mask (a:t) (b:t)
: Pure t
(requires True)
(ensures (fun c -> (v a = v b ==> v c = pow2 n - 1) /\
(v a <> v b ==> v c = 0)))
= let x = logxor a b in
let minus_x = minus x in
let x_or_minus_x = logor x minus_x in
let xnx = shift_right x_or_minus_x n_minus_one in
l... | val eq_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a = v b ==> v c = pow2 n - 1) /\ (v a <> v b ==> v c = 0)))
let eq_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a = v b ==> v c = pow2 n - 1) /\ (v a <> v b ==> v c = 0))) = | false | null | false | let x = logxor a b in
let minus_x = minus x in
let x_or_minus_x = logor x minus_x in
let xnx = shift_right x_or_minus_x n_minus_one in
let c = sub_mod xnx (uint_to_t 1) in
if a = b
then
(logxor_self (v a);
lognot_lemma_1 #n;
logor_lemma_1 (v x);
assert (v x = 0 /\ v minus_x = 0 /\ v x_or_minus_x = 0 /\ v ... | {
"checked_file": "FStar.UInt64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "FStar.UInt64.fsti"
} | [] | [
"FStar.UInt64.t",
"Prims.unit",
"Prims.op_Equality",
"Prims._assert",
"Prims.b2t",
"FStar.UInt.uint_t",
"FStar.UInt64.n",
"FStar.UInt64.v",
"FStar.UInt.ones",
"Prims.l_and",
"Prims.int",
"FStar.UInt.logor_lemma_1",
"FStar.UInt.lognot_lemma_1",
"FStar.UInt.logxor_self",
"Prims.bool",
"F... | [] | (*
Copyright 2008-2019 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... | false | false | FStar.UInt64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val eq_mask (a b: t)
: Pure t
(requires True)
(ensures (fun c -> (v a = v b ==> v c = pow2 n - 1) /\ (v a <> v b ==> v c = 0))) | [] | FStar.UInt64.eq_mask | {
"file_name": "ulib/FStar.UInt64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt64.t -> b: FStar.UInt64.t -> Prims.Pure FStar.UInt64.t | {
"end_col": 5,
"end_line": 282,
"start_col": 3,
"start_line": 260
} |
Prims.Tot | val wrap_slice (#a: Type0) (s: Seq.seq a) (i: int) : Seq.seq a | [
{
"abbrev": false,
"full_module": "Vale.Lib.BufferViewHelpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
... | false | let wrap_slice (#a:Type0) (s:Seq.seq a) (i:int) : Seq.seq a =
Seq.slice s 0 (if 0 <= i && i <= Seq.length s then i else 0) | val wrap_slice (#a: Type0) (s: Seq.seq a) (i: int) : Seq.seq a
let wrap_slice (#a: Type0) (s: Seq.seq a) (i: int) : Seq.seq a = | false | null | false | Seq.slice s 0 (if 0 <= i && i <= Seq.length s then i else 0) | {
"checked_file": "Vale.Wrapper.X64.GCMencryptOpt256.fst.checked",
"dependencies": [
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Stdcalls.X64.GCMencryptOpt.fst.checked",
"Vale.SHA.Simplify_Sha.fsti.checked",
"Vale.Lib.BufferViewHelpers.fst.checked",
"Vale.Int... | [
"total"
] | [
"FStar.Seq.Base.seq",
"FStar.Integers.int",
"FStar.Seq.Base.slice",
"Prims.op_AmpAmp",
"FStar.Integers.op_Less_Equals",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"FStar.Seq.Base.length",
"Prims.bool",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual"
] | [] | module Vale.Wrapper.X64.GCMencryptOpt256
open FStar.Mul
open Vale.Stdcalls.X64.GCMencryptOpt
open Vale.AsLowStar.MemoryHelpers
open Vale.X64.MemoryAdapters
module V = Vale.X64.Decls
open Vale.SHA.Simplify_Sha
open Vale.AES.Gcm_simplify
open Vale.AES.GCM_helpers
open FStar.Calc
open FStar.Int.Cast
open FStar.Integers
o... | false | false | Vale.Wrapper.X64.GCMencryptOpt256.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val wrap_slice (#a: Type0) (s: Seq.seq a) (i: int) : Seq.seq a | [] | Vale.Wrapper.X64.GCMencryptOpt256.wrap_slice | {
"file_name": "vale/code/arch/x64/interop/Vale.Wrapper.X64.GCMencryptOpt256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: FStar.Seq.Base.seq a -> i: FStar.Integers.int -> FStar.Seq.Base.seq a | {
"end_col": 62,
"end_line": 18,
"start_col": 2,
"start_line": 18
} |
FStar.Pervasives.Lemma | val length_div (b: uint8_p)
: Lemma (requires B.length b = 16) (ensures DV.length (get_downview b) / 16 = 1) | [
{
"abbrev": false,
"full_module": "Vale.Lib.BufferViewHelpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
... | false | let length_div (b:uint8_p) : Lemma
(requires B.length b = 16)
(ensures DV.length (get_downview b) / 16 = 1)
= DV.length_eq (get_downview b) | val length_div (b: uint8_p)
: Lemma (requires B.length b = 16) (ensures DV.length (get_downview b) / 16 = 1)
let length_div (b: uint8_p)
: Lemma (requires B.length b = 16) (ensures DV.length (get_downview b) / 16 = 1) = | false | null | true | DV.length_eq (get_downview b) | {
"checked_file": "Vale.Wrapper.X64.GCMencryptOpt256.fst.checked",
"dependencies": [
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Stdcalls.X64.GCMencryptOpt.fst.checked",
"Vale.SHA.Simplify_Sha.fsti.checked",
"Vale.Lib.BufferViewHelpers.fst.checked",
"Vale.Int... | [
"lemma"
] | [
"Vale.Wrapper.X64.GCMencryptOpt256.uint8_p",
"LowStar.BufferView.Down.length_eq",
"FStar.UInt8.t",
"Vale.Interop.Types.get_downview",
"Vale.Arch.HeapTypes_s.TUInt8",
"LowStar.Buffer.trivial_preorder",
"Prims.unit",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"LowStar.Monotonic.Buffer.length",... | [] | module Vale.Wrapper.X64.GCMencryptOpt256
open FStar.Mul
open Vale.Stdcalls.X64.GCMencryptOpt
open Vale.AsLowStar.MemoryHelpers
open Vale.X64.MemoryAdapters
module V = Vale.X64.Decls
open Vale.SHA.Simplify_Sha
open Vale.AES.Gcm_simplify
open Vale.AES.GCM_helpers
open FStar.Calc
open FStar.Int.Cast
open FStar.Integers
o... | false | false | Vale.Wrapper.X64.GCMencryptOpt256.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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... | null | val length_div (b: uint8_p)
: Lemma (requires B.length b = 16) (ensures DV.length (get_downview b) / 16 = 1) | [] | Vale.Wrapper.X64.GCMencryptOpt256.length_div | {
"file_name": "vale/code/arch/x64/interop/Vale.Wrapper.X64.GCMencryptOpt256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Vale.Wrapper.X64.GCMencryptOpt256.uint8_p
-> FStar.Pervasives.Lemma (requires LowStar.Monotonic.Buffer.length b = 16)
(ensures LowStar.BufferView.Down.length (Vale.Interop.Types.get_downview b) / 16 = 1) | {
"end_col": 33,
"end_line": 27,
"start_col": 4,
"start_line": 27
} |
FStar.Pervasives.Lemma | val math_cast_aux (n: UInt64.t)
: Lemma (requires UInt64.v n < pow2 32) (ensures UInt32.v (uint64_to_uint32 n) = UInt64.v n) | [
{
"abbrev": false,
"full_module": "Vale.Lib.BufferViewHelpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
... | false | let math_cast_aux (n:UInt64.t) : Lemma
(requires UInt64.v n < pow2 32)
(ensures UInt32.v (uint64_to_uint32 n) = UInt64.v n)
= FStar.Math.Lemmas.small_mod (UInt64.v n) (pow2 32) | val math_cast_aux (n: UInt64.t)
: Lemma (requires UInt64.v n < pow2 32) (ensures UInt32.v (uint64_to_uint32 n) = UInt64.v n)
let math_cast_aux (n: UInt64.t)
: Lemma (requires UInt64.v n < pow2 32) (ensures UInt32.v (uint64_to_uint32 n) = UInt64.v n) = | false | null | true | FStar.Math.Lemmas.small_mod (UInt64.v n) (pow2 32) | {
"checked_file": "Vale.Wrapper.X64.GCMencryptOpt256.fst.checked",
"dependencies": [
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Stdcalls.X64.GCMencryptOpt.fst.checked",
"Vale.SHA.Simplify_Sha.fsti.checked",
"Vale.Lib.BufferViewHelpers.fst.checked",
"Vale.Int... | [
"lemma"
] | [
"FStar.UInt64.t",
"FStar.Math.Lemmas.small_mod",
"FStar.UInt64.v",
"Prims.pow2",
"Prims.unit",
"Prims.b2t",
"FStar.Integers.op_Less",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"Prims.squash",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
... | [] | module Vale.Wrapper.X64.GCMencryptOpt256
open FStar.Mul
open Vale.Stdcalls.X64.GCMencryptOpt
open Vale.AsLowStar.MemoryHelpers
open Vale.X64.MemoryAdapters
module V = Vale.X64.Decls
open Vale.SHA.Simplify_Sha
open Vale.AES.Gcm_simplify
open Vale.AES.GCM_helpers
open FStar.Calc
open FStar.Int.Cast
open FStar.Integers
o... | false | false | Vale.Wrapper.X64.GCMencryptOpt256.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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... | null | val math_cast_aux (n: UInt64.t)
: Lemma (requires UInt64.v n < pow2 32) (ensures UInt32.v (uint64_to_uint32 n) = UInt64.v n) | [] | Vale.Wrapper.X64.GCMencryptOpt256.math_cast_aux | {
"file_name": "vale/code/arch/x64/interop/Vale.Wrapper.X64.GCMencryptOpt256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n: FStar.UInt64.t
-> FStar.Pervasives.Lemma (requires FStar.UInt64.v n < Prims.pow2 32)
(ensures FStar.UInt32.v (FStar.Int.Cast.uint64_to_uint32 n) = FStar.UInt64.v n) | {
"end_col": 54,
"end_line": 521,
"start_col": 4,
"start_line": 521
} |
FStar.Pervasives.Lemma | val length_aux6 (b: uint8_p) : Lemma (B.length b = DV.length (get_downview b)) | [
{
"abbrev": false,
"full_module": "Vale.Lib.BufferViewHelpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
... | false | let length_aux6 (b:uint8_p) : Lemma (B.length b = DV.length (get_downview b))
= DV.length_eq (get_downview b) | val length_aux6 (b: uint8_p) : Lemma (B.length b = DV.length (get_downview b))
let length_aux6 (b: uint8_p) : Lemma (B.length b = DV.length (get_downview b)) = | false | null | true | DV.length_eq (get_downview b) | {
"checked_file": "Vale.Wrapper.X64.GCMencryptOpt256.fst.checked",
"dependencies": [
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Stdcalls.X64.GCMencryptOpt.fst.checked",
"Vale.SHA.Simplify_Sha.fsti.checked",
"Vale.Lib.BufferViewHelpers.fst.checked",
"Vale.Int... | [
"lemma"
] | [
"Vale.Wrapper.X64.GCMencryptOpt256.uint8_p",
"LowStar.BufferView.Down.length_eq",
"FStar.UInt8.t",
"Vale.Interop.Types.get_downview",
"Vale.Arch.HeapTypes_s.TUInt8",
"LowStar.Buffer.trivial_preorder",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
... | [] | module Vale.Wrapper.X64.GCMencryptOpt256
open FStar.Mul
open Vale.Stdcalls.X64.GCMencryptOpt
open Vale.AsLowStar.MemoryHelpers
open Vale.X64.MemoryAdapters
module V = Vale.X64.Decls
open Vale.SHA.Simplify_Sha
open Vale.AES.Gcm_simplify
open Vale.AES.GCM_helpers
open FStar.Calc
open FStar.Int.Cast
open FStar.Integers
o... | false | false | Vale.Wrapper.X64.GCMencryptOpt256.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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... | null | val length_aux6 (b: uint8_p) : Lemma (B.length b = DV.length (get_downview b)) | [] | Vale.Wrapper.X64.GCMencryptOpt256.length_aux6 | {
"file_name": "vale/code/arch/x64/interop/Vale.Wrapper.X64.GCMencryptOpt256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Vale.Wrapper.X64.GCMencryptOpt256.uint8_p
-> FStar.Pervasives.Lemma
(ensures
LowStar.Monotonic.Buffer.length b =
LowStar.BufferView.Down.length (Vale.Interop.Types.get_downview b)) | {
"end_col": 33,
"end_line": 762,
"start_col": 4,
"start_line": 762
} |
FStar.Pervasives.Lemma | val lemma_same_seq_dv (h: HS.mem) (b: uint8_p)
: Lemma (Seq.equal (B.as_seq h b) (DV.as_seq h (get_downview b))) | [
{
"abbrev": false,
"full_module": "Vale.Lib.BufferViewHelpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
... | false | let lemma_same_seq_dv (h:HS.mem) (b:uint8_p) : Lemma
(Seq.equal (B.as_seq h b) (DV.as_seq h (get_downview b))) =
let db = get_downview b in
DV.length_eq db;
let aux (i:nat{i < B.length b}) : Lemma (Seq.index (B.as_seq h b) i == Seq.index (DV.as_seq h db) i) =
DV.as_seq_sel h db i;
DV.get_sel h db i;
... | val lemma_same_seq_dv (h: HS.mem) (b: uint8_p)
: Lemma (Seq.equal (B.as_seq h b) (DV.as_seq h (get_downview b)))
let lemma_same_seq_dv (h: HS.mem) (b: uint8_p)
: Lemma (Seq.equal (B.as_seq h b) (DV.as_seq h (get_downview b))) = | false | null | true | let db = get_downview b in
DV.length_eq db;
let aux (i: nat{i < B.length b})
: Lemma (Seq.index (B.as_seq h b) i == Seq.index (DV.as_seq h db) i) =
DV.as_seq_sel h db i;
DV.get_sel h db i;
Vale.Interop.Views.put8_reveal ()
in
Classical.forall_intro aux | {
"checked_file": "Vale.Wrapper.X64.GCMencryptOpt256.fst.checked",
"dependencies": [
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Stdcalls.X64.GCMencryptOpt.fst.checked",
"Vale.SHA.Simplify_Sha.fsti.checked",
"Vale.Lib.BufferViewHelpers.fst.checked",
"Vale.Int... | [
"lemma"
] | [
"FStar.Monotonic.HyperStack.mem",
"Vale.Wrapper.X64.GCMencryptOpt256.uint8_p",
"FStar.Classical.forall_intro",
"FStar.Integers.nat",
"Prims.b2t",
"FStar.Integers.op_Less",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"LowStar.Monotonic.Buffer.length",
"FStar.UInt8.t",
"LowStar.Buffer.tri... | [] | module Vale.Wrapper.X64.GCMencryptOpt256
open FStar.Mul
open Vale.Stdcalls.X64.GCMencryptOpt
open Vale.AsLowStar.MemoryHelpers
open Vale.X64.MemoryAdapters
module V = Vale.X64.Decls
open Vale.SHA.Simplify_Sha
open Vale.AES.Gcm_simplify
open Vale.AES.GCM_helpers
open FStar.Calc
open FStar.Int.Cast
open FStar.Integers
o... | false | false | Vale.Wrapper.X64.GCMencryptOpt256.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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... | null | val lemma_same_seq_dv (h: HS.mem) (b: uint8_p)
: Lemma (Seq.equal (B.as_seq h b) (DV.as_seq h (get_downview b))) | [] | Vale.Wrapper.X64.GCMencryptOpt256.lemma_same_seq_dv | {
"file_name": "vale/code/arch/x64/interop/Vale.Wrapper.X64.GCMencryptOpt256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> b: Vale.Wrapper.X64.GCMencryptOpt256.uint8_p
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (LowStar.Monotonic.Buffer.as_seq h b)
(LowStar.BufferView.Down.as_seq h (Vale.Interop.Types.get_downview b))) | {
"end_col": 31,
"end_line": 424,
"start_col": 61,
"start_line": 417
} |
FStar.Pervasives.Lemma | val lemma_identical_uv (b: uint8_p) (h0 h1: HS.mem)
: Lemma (requires B.length b % 16 = 0 /\ Seq.equal (B.as_seq h0 b) (B.as_seq h1 b))
(ensures
(let b_d = get_downview b in
length_aux3 b (B.length b / 16);
let b_u = UV.mk_buffer b_d Vale.Interop.Views.up_view128 in
Seq.e... | [
{
"abbrev": false,
"full_module": "Vale.Lib.BufferViewHelpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
... | false | let lemma_identical_uv (b:uint8_p) (h0 h1:HS.mem) : Lemma
(requires B.length b % 16 = 0 /\ Seq.equal (B.as_seq h0 b) (B.as_seq h1 b))
(ensures (
let b_d = get_downview b in
length_aux3 b (B.length b / 16);
let b_u = UV.mk_buffer b_d Vale.Interop.Views.up_view128 in
Seq.equal (UV.as_seq h0 b_u) (UV.a... | val lemma_identical_uv (b: uint8_p) (h0 h1: HS.mem)
: Lemma (requires B.length b % 16 = 0 /\ Seq.equal (B.as_seq h0 b) (B.as_seq h1 b))
(ensures
(let b_d = get_downview b in
length_aux3 b (B.length b / 16);
let b_u = UV.mk_buffer b_d Vale.Interop.Views.up_view128 in
Seq.e... | false | null | true | lemma_dv_equal Vale.Interop.Views.down_view8 b h0 h1;
length_aux3 b (B.length b / 16);
lemma_uv_equal Vale.Interop.Views.up_view128 (get_downview b) h0 h1 | {
"checked_file": "Vale.Wrapper.X64.GCMencryptOpt256.fst.checked",
"dependencies": [
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Stdcalls.X64.GCMencryptOpt.fst.checked",
"Vale.SHA.Simplify_Sha.fsti.checked",
"Vale.Lib.BufferViewHelpers.fst.checked",
"Vale.Int... | [
"lemma"
] | [
"Vale.Wrapper.X64.GCMencryptOpt256.uint8_p",
"FStar.Monotonic.HyperStack.mem",
"Vale.Lib.BufferViewHelpers.lemma_uv_equal",
"FStar.UInt8.t",
"Vale.Def.Types_s.quad32",
"Vale.Interop.Views.up_view128",
"Vale.Interop.Types.get_downview",
"Vale.Arch.HeapTypes_s.TUInt8",
"LowStar.Buffer.trivial_preorder... | [] | module Vale.Wrapper.X64.GCMencryptOpt256
open FStar.Mul
open Vale.Stdcalls.X64.GCMencryptOpt
open Vale.AsLowStar.MemoryHelpers
open Vale.X64.MemoryAdapters
module V = Vale.X64.Decls
open Vale.SHA.Simplify_Sha
open Vale.AES.Gcm_simplify
open Vale.AES.GCM_helpers
open FStar.Calc
open FStar.Int.Cast
open FStar.Integers
o... | false | false | Vale.Wrapper.X64.GCMencryptOpt256.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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... | null | val lemma_identical_uv (b: uint8_p) (h0 h1: HS.mem)
: Lemma (requires B.length b % 16 = 0 /\ Seq.equal (B.as_seq h0 b) (B.as_seq h1 b))
(ensures
(let b_d = get_downview b in
length_aux3 b (B.length b / 16);
let b_u = UV.mk_buffer b_d Vale.Interop.Views.up_view128 in
Seq.e... | [] | Vale.Wrapper.X64.GCMencryptOpt256.lemma_identical_uv | {
"file_name": "vale/code/arch/x64/interop/Vale.Wrapper.X64.GCMencryptOpt256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
b: Vale.Wrapper.X64.GCMencryptOpt256.uint8_p ->
h0: FStar.Monotonic.HyperStack.mem ->
h1: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.length b % 16 = 0 /\
FStar.Seq.Base.equal (LowStar.Monotonic.Buffer.as_seq h0 b)
(LowStar.M... | {
"end_col": 71,
"end_line": 758,
"start_col": 4,
"start_line": 756
} |
FStar.Pervasives.Lemma | val lemma_slice_uv_extra (b b_start b_extra: uint8_p) (h: HS.mem)
: Lemma
(requires
B.length b_start = (B.length b / 16) * 16 /\
b_start == B.gsub b 0ul (UInt32.uint_to_t (B.length b_start)) /\ B.length b_extra = 16 /\
Seq.equal (B.as_seq h b)
(Seq.slice (Seq.append (B.as_seq... | [
{
"abbrev": false,
"full_module": "Vale.Lib.BufferViewHelpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
... | false | let lemma_slice_uv_extra (b:uint8_p) (b_start:uint8_p) (b_extra:uint8_p) (h:HS.mem) : Lemma
(requires
B.length b_start = B.length b / 16 * 16 /\
b_start == B.gsub b 0ul (UInt32.uint_to_t (B.length b_start)) /\
B.length b_extra = 16 /\
Seq.equal
(B.as_seq h b)
(Seq.slice (Seq.append (B.as_s... | val lemma_slice_uv_extra (b b_start b_extra: uint8_p) (h: HS.mem)
: Lemma
(requires
B.length b_start = (B.length b / 16) * 16 /\
b_start == B.gsub b 0ul (UInt32.uint_to_t (B.length b_start)) /\ B.length b_extra = 16 /\
Seq.equal (B.as_seq h b)
(Seq.slice (Seq.append (B.as_seq... | false | null | true | let b_start_d = get_downview b_start in
length_aux6 b_start;
let b_start_u = UV.mk_buffer b_start_d Vale.Interop.Views.up_view128 in
let b_extra_d = get_downview b_extra in
length_aux6 b_extra;
let b_extra_u = UV.mk_buffer b_extra_d Vale.Interop.Views.up_view128 in
let suv = Seq.append (UV.as_seq h b_start_u) (UV.as_se... | {
"checked_file": "Vale.Wrapper.X64.GCMencryptOpt256.fst.checked",
"dependencies": [
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Stdcalls.X64.GCMencryptOpt.fst.checked",
"Vale.SHA.Simplify_Sha.fsti.checked",
"Vale.Lib.BufferViewHelpers.fst.checked",
"Vale.Int... | [
"lemma"
] | [
"Vale.Wrapper.X64.GCMencryptOpt256.uint8_p",
"FStar.Monotonic.HyperStack.mem",
"FStar.Calc.calc_finish",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Prims.eq2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Vale.Wrapper.X64.GCMencryptOpt256.wr... | [] | module Vale.Wrapper.X64.GCMencryptOpt256
open FStar.Mul
open Vale.Stdcalls.X64.GCMencryptOpt
open Vale.AsLowStar.MemoryHelpers
open Vale.X64.MemoryAdapters
module V = Vale.X64.Decls
open Vale.SHA.Simplify_Sha
open Vale.AES.Gcm_simplify
open Vale.AES.GCM_helpers
open FStar.Calc
open FStar.Int.Cast
open FStar.Integers
o... | false | false | Vale.Wrapper.X64.GCMencryptOpt256.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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... | null | val lemma_slice_uv_extra (b b_start b_extra: uint8_p) (h: HS.mem)
: Lemma
(requires
B.length b_start = (B.length b / 16) * 16 /\
b_start == B.gsub b 0ul (UInt32.uint_to_t (B.length b_start)) /\ B.length b_extra = 16 /\
Seq.equal (B.as_seq h b)
(Seq.slice (Seq.append (B.as_seq... | [] | Vale.Wrapper.X64.GCMencryptOpt256.lemma_slice_uv_extra | {
"file_name": "vale/code/arch/x64/interop/Vale.Wrapper.X64.GCMencryptOpt256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
b: Vale.Wrapper.X64.GCMencryptOpt256.uint8_p ->
b_start: Vale.Wrapper.X64.GCMencryptOpt256.uint8_p ->
b_extra: Vale.Wrapper.X64.GCMencryptOpt256.uint8_p ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.length b_start = (LowStar.Monotonic.... | {
"end_col": 4,
"end_line": 831,
"start_col": 2,
"start_line": 785
} |
FStar.Pervasives.Lemma | val lemma_slice_sub (b b_sub b_extra: uint8_p) (h: HS.mem)
: Lemma
(requires
B.length b_extra = 16 /\ B.length b_sub = (B.length b / 16) * 16 /\
b_sub == B.gsub b 0ul (UInt32.uint_to_t (B.length b_sub)) /\
Seq.equal (Seq.slice (B.as_seq h b) (B.length b_sub) (B.length b_sub + B.length ... | [
{
"abbrev": false,
"full_module": "Vale.Lib.BufferViewHelpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
... | false | let lemma_slice_sub (b:uint8_p) (b_sub:uint8_p) (b_extra:uint8_p) (h:HS.mem) : Lemma
(requires B.length b_extra = 16 /\ B.length b_sub = B.length b / 16 * 16 /\
b_sub == B.gsub b 0ul (UInt32.uint_to_t (B.length b_sub)) /\
Seq.equal
(Seq.slice (B.as_seq h b) (B.length b_sub) (B.length b_sub + B.length b ... | val lemma_slice_sub (b b_sub b_extra: uint8_p) (h: HS.mem)
: Lemma
(requires
B.length b_extra = 16 /\ B.length b_sub = (B.length b / 16) * 16 /\
b_sub == B.gsub b 0ul (UInt32.uint_to_t (B.length b_sub)) /\
Seq.equal (Seq.slice (B.as_seq h b) (B.length b_sub) (B.length b_sub + B.length ... | false | null | true | calc ( == ) {
Seq.slice (Seq.append (B.as_seq h b_sub) (B.as_seq h b_extra)) 0 (B.length b);
( == ) { Seq.lemma_eq_intro (Seq.slice (Seq.append (B.as_seq h b_sub) (B.as_seq h b_extra))
0
(B.length b))
(Seq.append (B.as_seq h b_sub) (Seq.slice (B.as_seq h b_extra) 0 (B.length b % 16))) }
Seq.ap... | {
"checked_file": "Vale.Wrapper.X64.GCMencryptOpt256.fst.checked",
"dependencies": [
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Stdcalls.X64.GCMencryptOpt.fst.checked",
"Vale.SHA.Simplify_Sha.fsti.checked",
"Vale.Lib.BufferViewHelpers.fst.checked",
"Vale.Int... | [
"lemma"
] | [
"Vale.Wrapper.X64.GCMencryptOpt256.uint8_p",
"FStar.Monotonic.HyperStack.mem",
"FStar.Calc.calc_finish",
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"Prims.eq2",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.append",
"LowStar.Monotonic.Buffer.as_seq",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.B... | [] | module Vale.Wrapper.X64.GCMencryptOpt256
open FStar.Mul
open Vale.Stdcalls.X64.GCMencryptOpt
open Vale.AsLowStar.MemoryHelpers
open Vale.X64.MemoryAdapters
module V = Vale.X64.Decls
open Vale.SHA.Simplify_Sha
open Vale.AES.Gcm_simplify
open Vale.AES.GCM_helpers
open FStar.Calc
open FStar.Int.Cast
open FStar.Integers
o... | false | false | Vale.Wrapper.X64.GCMencryptOpt256.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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... | null | val lemma_slice_sub (b b_sub b_extra: uint8_p) (h: HS.mem)
: Lemma
(requires
B.length b_extra = 16 /\ B.length b_sub = (B.length b / 16) * 16 /\
b_sub == B.gsub b 0ul (UInt32.uint_to_t (B.length b_sub)) /\
Seq.equal (Seq.slice (B.as_seq h b) (B.length b_sub) (B.length b_sub + B.length ... | [] | Vale.Wrapper.X64.GCMencryptOpt256.lemma_slice_sub | {
"file_name": "vale/code/arch/x64/interop/Vale.Wrapper.X64.GCMencryptOpt256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
b: Vale.Wrapper.X64.GCMencryptOpt256.uint8_p ->
b_sub: Vale.Wrapper.X64.GCMencryptOpt256.uint8_p ->
b_extra: Vale.Wrapper.X64.GCMencryptOpt256.uint8_p ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.length b_extra = 16 /\
LowStar... | {
"end_col": 3,
"end_line": 878,
"start_col": 2,
"start_line": 857
} |
FStar.Pervasives.Lemma | val lemma_uv_split (h: HS.mem) (b: uint8_p) (n: UInt32.t)
: Lemma (requires B.length b % 16 = 0 /\ UInt32.v n % 16 = 0 /\ UInt32.v n <= B.length b)
(ensures
(let b1 = B.gsub b 0ul n in
let b2 = B.gsub b n (UInt32.uint_to_t (B.length b) - n) in
let b1_d = get_downview b1 in
... | [
{
"abbrev": false,
"full_module": "Vale.Lib.BufferViewHelpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
... | false | let lemma_uv_split (h:HS.mem) (b:uint8_p) (n:UInt32.t) : Lemma
(requires B.length b % 16 = 0 /\ UInt32.v n % 16 = 0 /\ UInt32.v n <= B.length b)
(ensures (
let b1 = B.gsub b 0ul n in
let b2 = B.gsub b n (UInt32.uint_to_t (B.length b) - n) in
let b1_d = get_downview b1 in
length_aux3 b1 (B.length b1 ... | val lemma_uv_split (h: HS.mem) (b: uint8_p) (n: UInt32.t)
: Lemma (requires B.length b % 16 = 0 /\ UInt32.v n % 16 = 0 /\ UInt32.v n <= B.length b)
(ensures
(let b1 = B.gsub b 0ul n in
let b2 = B.gsub b n (UInt32.uint_to_t (B.length b) - n) in
let b1_d = get_downview b1 in
... | false | null | true | let b1 = B.gsub b 0ul n in
let b2 = B.gsub b n (UInt32.uint_to_t (B.length b) - n) in
let b1_d = get_downview b1 in
length_aux3 b1 (B.length b1 / 16);
let b1_u = UV.mk_buffer b1_d Vale.Interop.Views.up_view128 in
let b2_d = get_downview b2 in
length_aux3 b2 (B.length b2 / 16);
let b2_u = UV.mk_buffer b2_d Vale.Interop.... | {
"checked_file": "Vale.Wrapper.X64.GCMencryptOpt256.fst.checked",
"dependencies": [
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Stdcalls.X64.GCMencryptOpt.fst.checked",
"Vale.SHA.Simplify_Sha.fsti.checked",
"Vale.Lib.BufferViewHelpers.fst.checked",
"Vale.Int... | [
"lemma"
] | [
"FStar.Monotonic.HyperStack.mem",
"Vale.Wrapper.X64.GCMencryptOpt256.uint8_p",
"FStar.UInt32.t",
"FStar.Classical.forall_intro",
"FStar.Integers.nat",
"Prims.b2t",
"FStar.Integers.op_Less",
"FStar.Integers.Signed",
"FStar.Integers.Winfinite",
"FStar.Seq.Base.length",
"Vale.Def.Types_s.quad32",
... | [] | module Vale.Wrapper.X64.GCMencryptOpt256
open FStar.Mul
open Vale.Stdcalls.X64.GCMencryptOpt
open Vale.AsLowStar.MemoryHelpers
open Vale.X64.MemoryAdapters
module V = Vale.X64.Decls
open Vale.SHA.Simplify_Sha
open Vale.AES.Gcm_simplify
open Vale.AES.GCM_helpers
open FStar.Calc
open FStar.Int.Cast
open FStar.Integers
o... | false | false | Vale.Wrapper.X64.GCMencryptOpt256.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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... | null | val lemma_uv_split (h: HS.mem) (b: uint8_p) (n: UInt32.t)
: Lemma (requires B.length b % 16 = 0 /\ UInt32.v n % 16 = 0 /\ UInt32.v n <= B.length b)
(ensures
(let b1 = B.gsub b 0ul n in
let b2 = B.gsub b n (UInt32.uint_to_t (B.length b) - n) in
let b1_d = get_downview b1 in
... | [] | Vale.Wrapper.X64.GCMencryptOpt256.lemma_uv_split | {
"file_name": "vale/code/arch/x64/interop/Vale.Wrapper.X64.GCMencryptOpt256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
h: FStar.Monotonic.HyperStack.mem ->
b: Vale.Wrapper.X64.GCMencryptOpt256.uint8_p ->
n: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.length b % 16 = 0 /\ FStar.UInt32.v n % 16 = 0 /\
FStar.UInt32.v n <= LowStar.Monotonic.Buffer.length b)
(ensures... | {
"end_col": 33,
"end_line": 516,
"start_col": 5,
"start_line": 443
} |
Prims.Tot | val gcm256_encrypt_opt_stdcall: Vale.Wrapper.X64.GCMencryptOpt.encrypt_opt_stdcall_st AES_256 | [
{
"abbrev": false,
"full_module": "Vale.Lib.BufferViewHelpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
... | false | let gcm256_encrypt_opt_stdcall key iv plain_b plain_len auth_b auth_len iv_b out_b tag_b keys_b hkeys_b scratch_b =
let h0 = get() in
push_frame();
// Extra space to have a full input/output with length % 16 = 0
let inout_b = B.sub scratch_b 0ul 16ul in
// Same for auth_b
let abytes_b = B.sub scratch_b 16u... | val gcm256_encrypt_opt_stdcall: Vale.Wrapper.X64.GCMencryptOpt.encrypt_opt_stdcall_st AES_256
let gcm256_encrypt_opt_stdcall
key
iv
plain_b
plain_len
auth_b
auth_len
iv_b
out_b
tag_b
keys_b
hkeys_b
scratch_b
= | false | null | false | let h0 = get () in
push_frame ();
let inout_b = B.sub scratch_b 0ul 16ul in
let abytes_b = B.sub scratch_b 16ul 16ul in
let scratch_b = B.sub scratch_b 32ul 144ul in
math_cast_aux plain_len;
math_cast_aux auth_len;
let plain_len' = (uint64_to_uint32 plain_len / 16ul) * 16ul in
let auth_len' = (uint64_to_uint32 auth_len... | {
"checked_file": "Vale.Wrapper.X64.GCMencryptOpt256.fst.checked",
"dependencies": [
"Vale.X64.MemoryAdapters.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.Stdcalls.X64.GCMencryptOpt.fst.checked",
"Vale.SHA.Simplify_Sha.fsti.checked",
"Vale.Lib.BufferViewHelpers.fst.checked",
"Vale.Int... | [
"total"
] | [
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat32",
"Vale.AES.GCM_s.supported_iv_LE",
"Vale.Wrapper.X64.GCMencryptOpt.uint8_p",
"Vale.Wrapper.X64.GCMencryptOpt.uint64",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Prims._assert",
"Vale.Def.Types_s.nat8",
"Prims.l_and",
"FS... | [] | module Vale.Wrapper.X64.GCMencryptOpt256
open FStar.Mul
open Vale.Stdcalls.X64.GCMencryptOpt
open Vale.AsLowStar.MemoryHelpers
open Vale.X64.MemoryAdapters
module V = Vale.X64.Decls
open Vale.SHA.Simplify_Sha
open Vale.AES.Gcm_simplify
open Vale.AES.GCM_helpers
open FStar.Calc
open FStar.Int.Cast
open FStar.Integers
o... | false | true | Vale.Wrapper.X64.GCMencryptOpt256.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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... | null | val gcm256_encrypt_opt_stdcall: Vale.Wrapper.X64.GCMencryptOpt.encrypt_opt_stdcall_st AES_256 | [] | Vale.Wrapper.X64.GCMencryptOpt256.gcm256_encrypt_opt_stdcall | {
"file_name": "vale/code/arch/x64/interop/Vale.Wrapper.X64.GCMencryptOpt256.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.Wrapper.X64.GCMencryptOpt.encrypt_opt_stdcall_st Vale.AES.AES_common_s.AES_256 | {
"end_col": 13,
"end_line": 1003,
"start_col": 115,
"start_line": 883
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_modu... | false | let t = input_buffer | let t = | false | null | false | input_buffer | {
"checked_file": "EverParse3d.InputStream.Buffer.Aux.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",... | [
"total"
] | [
"EverParse3d.InputStream.Buffer.Aux.input_buffer"
] | [] | module EverParse3d.InputStream.Buffer.Aux
(* This module is here to break circularity in KaRaMeL bundles (because Prims must be in the EverParse bundle because of the string type, as opposed to C,FStar,LowStar.) *)
module IB = EverParse3d.InputBuffer
module IR = EverParse3d.Readable
module LP = LowParse.Low.Base
modu... | false | true | EverParse3d.InputStream.Buffer.Aux.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"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... | null | val t : Type0 | [] | EverParse3d.InputStream.Buffer.Aux.t | {
"file_name": "src/3d/prelude/buffer/EverParse3d.InputStream.Buffer.Aux.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | Type0 | {
"end_col": 20,
"end_line": 35,
"start_col": 8,
"start_line": 35
} | |
FStar.HyperStack.ST.Stack | val default_error_handler
(typename_s fieldname reason: string)
(error_code: U64.t)
(context: B.pointer EverParse3d.ErrorCode.error_frame)
(input: input_buffer)
(start_pos: U64.t)
: HST.Stack unit
(requires (fun h -> B.live h context))
(ensures (fun h _ h' -> B.modifies (B.... | [
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full... | false | let default_error_handler
(typename_s: string)
(fieldname: string)
(reason: string)
(error_code: U64.t)
(context: B.pointer EverParse3d.ErrorCode.error_frame)
(input: input_buffer)
(start_pos: U64.t)
: HST.Stack unit
(requires (fun h -> B.live h context))
(ensures (fun h _ h' -> B.modifies (B.loc_buff... | val default_error_handler
(typename_s fieldname reason: string)
(error_code: U64.t)
(context: B.pointer EverParse3d.ErrorCode.error_frame)
(input: input_buffer)
(start_pos: U64.t)
: HST.Stack unit
(requires (fun h -> B.live h context))
(ensures (fun h _ h' -> B.modifies (B.... | true | null | false | if not (!*context).EverParse3d.ErrorCode.filled
then
context *=
{
EverParse3d.ErrorCode.filled = true;
EverParse3d.ErrorCode.start_pos = start_pos;
EverParse3d.ErrorCode.typename_s = typename_s;
EverParse3d.ErrorCode.fieldname = fieldname;
EverParse3d.ErrorCode.reason = reason;
EverParse3d.E... | {
"checked_file": "EverParse3d.InputStream.Buffer.Aux.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",... | [] | [
"Prims.string",
"FStar.UInt64.t",
"LowStar.Buffer.pointer",
"EverParse3d.ErrorCode.error_frame",
"EverParse3d.InputStream.Buffer.Aux.input_buffer",
"LowStar.BufferOps.op_Star_Equals",
"LowStar.Buffer.trivial_preorder",
"EverParse3d.ErrorCode.Mkerror_frame",
"Prims.unit",
"Prims.bool",
"Prims.op_... | [] | module EverParse3d.InputStream.Buffer.Aux
(* This module is here to break circularity in KaRaMeL bundles (because Prims must be in the EverParse bundle because of the string type, as opposed to C,FStar,LowStar.) *)
module IB = EverParse3d.InputBuffer
module IR = EverParse3d.Readable
module LP = LowParse.Low.Base
modu... | false | false | EverParse3d.InputStream.Buffer.Aux.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"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... | null | val default_error_handler
(typename_s fieldname reason: string)
(error_code: U64.t)
(context: B.pointer EverParse3d.ErrorCode.error_frame)
(input: input_buffer)
(start_pos: U64.t)
: HST.Stack unit
(requires (fun h -> B.live h context))
(ensures (fun h _ h' -> B.modifies (B.... | [] | EverParse3d.InputStream.Buffer.Aux.default_error_handler | {
"file_name": "src/3d/prelude/buffer/EverParse3d.InputStream.Buffer.Aux.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
typename_s: Prims.string ->
fieldname: Prims.string ->
reason: Prims.string ->
error_code: FStar.UInt64.t ->
context: LowStar.Buffer.pointer EverParse3d.ErrorCode.error_frame ->
input: EverParse3d.InputStream.Buffer.Aux.input_buffer ->
start_pos: FStar.UInt64.t
-> FStar.HyperStack.ST.Stac... | {
"end_col": 5,
"end_line": 100,
"start_col": 2,
"start_line": 91
} |
Prims.Ghost | val _perm_footprint (x: t)
: Ghost B.loc (requires True) (ensures (fun y -> (_footprint x) `B.loc_includes` y)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_modu... | false | let _perm_footprint
(x: t)
: Ghost B.loc
(requires True)
(ensures (fun y -> _footprint x `B.loc_includes` y))
= IR.loc_perm x.perm_of `B.loc_union` B.loc_buffer x.pos | val _perm_footprint (x: t)
: Ghost B.loc (requires True) (ensures (fun y -> (_footprint x) `B.loc_includes` y))
let _perm_footprint (x: t)
: Ghost B.loc (requires True) (ensures (fun y -> (_footprint x) `B.loc_includes` y)) = | false | null | false | (IR.loc_perm x.perm_of) `B.loc_union` (B.loc_buffer x.pos) | {
"checked_file": "EverParse3d.InputStream.Buffer.Aux.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",... | [] | [
"EverParse3d.InputStream.Buffer.Aux.t",
"LowStar.Monotonic.Buffer.loc_union",
"EverParse3d.Readable.loc_perm",
"LowParse.Bytes.byte",
"LowParse.Slice.__proj__Mkslice__item__base",
"EverParse3d.InputBuffer.triv",
"EverParse3d.InputBuffer.slice_of",
"FStar.Ghost.reveal",
"FStar.UInt32.t",
"EverParse... | [] | module EverParse3d.InputStream.Buffer.Aux
(* This module is here to break circularity in KaRaMeL bundles (because Prims must be in the EverParse bundle because of the string type, as opposed to C,FStar,LowStar.) *)
module IB = EverParse3d.InputBuffer
module IR = EverParse3d.Readable
module LP = LowParse.Low.Base
modu... | false | false | EverParse3d.InputStream.Buffer.Aux.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"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... | null | val _perm_footprint (x: t)
: Ghost B.loc (requires True) (ensures (fun y -> (_footprint x) `B.loc_includes` y)) | [] | EverParse3d.InputStream.Buffer.Aux._perm_footprint | {
"file_name": "src/3d/prelude/buffer/EverParse3d.InputStream.Buffer.Aux.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: EverParse3d.InputStream.Buffer.Aux.t -> Prims.Ghost LowStar.Monotonic.Buffer.loc | {
"end_col": 56,
"end_line": 63,
"start_col": 2,
"start_line": 63
} |
Prims.Ghost | val _footprint (x: t)
: Ghost B.loc
(requires True)
(ensures (fun y -> B.address_liveness_insensitive_locs `B.loc_includes` y)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_modu... | false | let _footprint
(x: t)
: Ghost B.loc
(requires True)
(ensures (fun y -> B.address_liveness_insensitive_locs `B.loc_includes` y))
= B.loc_buffer (IB.slice_of x.buf).LP.base `B.loc_union` IR.loc_perm x.perm_of `B.loc_union` B.loc_buffer x.pos | val _footprint (x: t)
: Ghost B.loc
(requires True)
(ensures (fun y -> B.address_liveness_insensitive_locs `B.loc_includes` y))
let _footprint (x: t)
: Ghost B.loc
(requires True)
(ensures (fun y -> B.address_liveness_insensitive_locs `B.loc_includes` y)) = | false | null | false | ((B.loc_buffer (IB.slice_of x.buf).LP.base) `B.loc_union` (IR.loc_perm x.perm_of))
`B.loc_union`
(B.loc_buffer x.pos) | {
"checked_file": "EverParse3d.InputStream.Buffer.Aux.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",... | [] | [
"EverParse3d.InputStream.Buffer.Aux.t",
"LowStar.Monotonic.Buffer.loc_union",
"LowStar.Monotonic.Buffer.loc_buffer",
"LowParse.Bytes.byte",
"LowParse.Slice.buffer_srel_of_srel",
"EverParse3d.InputBuffer.triv",
"LowParse.Slice.__proj__Mkslice__item__base",
"EverParse3d.InputBuffer.slice_of",
"FStar.G... | [] | module EverParse3d.InputStream.Buffer.Aux
(* This module is here to break circularity in KaRaMeL bundles (because Prims must be in the EverParse bundle because of the string type, as opposed to C,FStar,LowStar.) *)
module IB = EverParse3d.InputBuffer
module IR = EverParse3d.Readable
module LP = LowParse.Low.Base
modu... | false | false | EverParse3d.InputStream.Buffer.Aux.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"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... | null | val _footprint (x: t)
: Ghost B.loc
(requires True)
(ensures (fun y -> B.address_liveness_insensitive_locs `B.loc_includes` y)) | [] | EverParse3d.InputStream.Buffer.Aux._footprint | {
"file_name": "src/3d/prelude/buffer/EverParse3d.InputStream.Buffer.Aux.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: EverParse3d.InputStream.Buffer.Aux.t -> Prims.Ghost LowStar.Monotonic.Buffer.loc | {
"end_col": 111,
"end_line": 56,
"start_col": 2,
"start_line": 56
} |
Prims.Tot | val _live (x: t) (h: HS.mem) : Tot prop | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_modu... | false | let _live
(x: t)
(h: HS.mem)
: Tot prop
=
IB.live_input_buffer h x.buf x.perm_of /\
B.live h x.pos /\
U32.v (B.deref h x.pos) <= U32.v x.len /\
B.as_seq h (IB.slice_of x.buf).LP.base == Ghost.reveal x.g_all_buf /\
IR.unreadable h x.perm_of 0ul (B.deref h x.pos) /\
IR.readable h x.perm_of (B.deref h x.po... | val _live (x: t) (h: HS.mem) : Tot prop
let _live (x: t) (h: HS.mem) : Tot prop = | false | null | false | IB.live_input_buffer h x.buf x.perm_of /\ B.live h x.pos /\ U32.v (B.deref h x.pos) <= U32.v x.len /\
B.as_seq h (IB.slice_of x.buf).LP.base == Ghost.reveal x.g_all_buf /\
IR.unreadable h x.perm_of 0ul (B.deref h x.pos) /\ IR.readable h x.perm_of (B.deref h x.pos) x.len0 /\
Seq.slice (B.as_seq h (IB.slice_of x.buf).LP.... | {
"checked_file": "EverParse3d.InputStream.Buffer.Aux.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",... | [
"total"
] | [
"EverParse3d.InputStream.Buffer.Aux.t",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"EverParse3d.InputBuffer.live_input_buffer",
"FStar.Ghost.reveal",
"FStar.UInt32.t",
"EverParse3d.InputStream.Buffer.Aux.__proj__Mkinput_buffer__item__len0",
"EverParse3d.InputStream.Buffer.Aux.__proj__Mkinput_buf... | [] | module EverParse3d.InputStream.Buffer.Aux
(* This module is here to break circularity in KaRaMeL bundles (because Prims must be in the EverParse bundle because of the string type, as opposed to C,FStar,LowStar.) *)
module IB = EverParse3d.InputBuffer
module IR = EverParse3d.Readable
module LP = LowParse.Low.Base
modu... | false | true | EverParse3d.InputStream.Buffer.Aux.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"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... | null | val _live (x: t) (h: HS.mem) : Tot prop | [] | EverParse3d.InputStream.Buffer.Aux._live | {
"file_name": "src/3d/prelude/buffer/EverParse3d.InputStream.Buffer.Aux.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: EverParse3d.InputStream.Buffer.Aux.t -> h: FStar.Monotonic.HyperStack.mem -> Prims.prop | {
"end_col": 92,
"end_line": 49,
"start_col": 2,
"start_line": 43
} |
Prims.Ghost | val _get_remaining (x: t) (h: HS.mem)
: Ghost (Seq.seq U8.t) (requires (_live x h)) (ensures (fun y -> Seq.length y <= U32.v x.len)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_modu... | false | let _get_remaining
(x: t)
(h: HS.mem)
: Ghost (Seq.seq U8.t)
(requires (_live x h))
(ensures (fun y -> Seq.length y <= U32.v x.len))
=
let i = U32.v (B.deref h x.pos) in
Seq.slice x.g_all i (Seq.length x.g_all) | val _get_remaining (x: t) (h: HS.mem)
: Ghost (Seq.seq U8.t) (requires (_live x h)) (ensures (fun y -> Seq.length y <= U32.v x.len))
let _get_remaining (x: t) (h: HS.mem)
: Ghost (Seq.seq U8.t) (requires (_live x h)) (ensures (fun y -> Seq.length y <= U32.v x.len)) = | false | null | false | let i = U32.v (B.deref h x.pos) in
Seq.slice x.g_all i (Seq.length x.g_all) | {
"checked_file": "EverParse3d.InputStream.Buffer.Aux.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",... | [] | [
"EverParse3d.InputStream.Buffer.Aux.t",
"FStar.Monotonic.HyperStack.mem",
"FStar.Seq.Base.slice",
"FStar.UInt8.t",
"FStar.Ghost.reveal",
"FStar.Seq.Base.seq",
"EverParse3d.InputStream.Buffer.Aux.__proj__Mkinput_buffer__item__g_all",
"FStar.Seq.Base.length",
"FStar.UInt.uint_t",
"FStar.UInt32.v",
... | [] | module EverParse3d.InputStream.Buffer.Aux
(* This module is here to break circularity in KaRaMeL bundles (because Prims must be in the EverParse bundle because of the string type, as opposed to C,FStar,LowStar.) *)
module IB = EverParse3d.InputBuffer
module IR = EverParse3d.Readable
module LP = LowParse.Low.Base
modu... | false | false | EverParse3d.InputStream.Buffer.Aux.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"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... | null | val _get_remaining (x: t) (h: HS.mem)
: Ghost (Seq.seq U8.t) (requires (_live x h)) (ensures (fun y -> Seq.length y <= U32.v x.len)) | [] | EverParse3d.InputStream.Buffer.Aux._get_remaining | {
"file_name": "src/3d/prelude/buffer/EverParse3d.InputStream.Buffer.Aux.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: EverParse3d.InputStream.Buffer.Aux.t -> h: FStar.Monotonic.HyperStack.mem
-> Prims.Ghost (FStar.Seq.Base.seq FStar.UInt8.t) | {
"end_col": 42,
"end_line": 73,
"start_col": 1,
"start_line": 71
} |
Prims.Tot | val _zero_for_deref:FStar.UInt32.t | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_modul... | false | let _zero_for_deref : FStar.UInt32.t = 0ul | val _zero_for_deref:FStar.UInt32.t
let _zero_for_deref:FStar.UInt32.t = | false | null | false | 0ul | {
"checked_file": "C.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int32.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.chec... | [
"total"
] | [
"FStar.UInt32.__uint_to_t"
] | [] | module C
open FStar.HyperStack.ST
module HS = FStar.HyperStack
module U8 = FStar.UInt8
// This module contains a series of bindings that already exist in C. It receives
// a special treatment in Karamel (no prefixes, no .c/.h generated).
// - If a value already exists (e.g. char or srand), then it is defined via the... | false | true | C.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val _zero_for_deref:FStar.UInt32.t | [] | C._zero_for_deref | {
"file_name": "krmllib/C.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | FStar.UInt32.t | {
"end_col": 42,
"end_line": 65,
"start_col": 39,
"start_line": 65
} |
Prims.Tot | val rg_dummy (#a #rst: _) (rg: regional rst a) : Tot a | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full... | false | let rg_dummy #a #rst (rg:regional rst a)
: Tot a
= Rgl?.dummy rg | val rg_dummy (#a #rst: _) (rg: regional rst a) : Tot a
let rg_dummy #a #rst (rg: regional rst a) : Tot a = | false | null | false | Rgl?.dummy rg | {
"checked_file": "LowStar.Regional.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Gho... | [
"total"
] | [
"LowStar.Regional.regional",
"LowStar.Regional.__proj__Rgl__item__dummy"
] | [] | (*
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... | false | false | LowStar.Regional.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val rg_dummy (#a #rst: _) (rg: regional rst a) : Tot a | [] | LowStar.Regional.rg_dummy | {
"file_name": "ulib/LowStar.Regional.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | rg: LowStar.Regional.regional rst a -> a | {
"end_col": 15,
"end_line": 144,
"start_col": 2,
"start_line": 144
} |
Prims.GTot | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full... | false | let rg_inv #a #rst (rg: regional rst a) =
Rgl?.r_inv rg | let rg_inv #a #rst (rg: regional rst a) = | false | null | false | Rgl?.r_inv rg | {
"checked_file": "LowStar.Regional.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Gho... | [
"sometrivial"
] | [
"LowStar.Regional.regional",
"LowStar.Regional.__proj__Rgl__item__r_inv",
"FStar.Monotonic.HyperStack.mem"
] | [] | (*
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... | false | false | LowStar.Regional.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val rg_inv : rg: LowStar.Regional.regional rst a -> _: FStar.Monotonic.HyperStack.mem -> _: a -> Prims.GTot Type0 | [] | LowStar.Regional.rg_inv | {
"file_name": "ulib/LowStar.Regional.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | rg: LowStar.Regional.regional rst a -> _: FStar.Monotonic.HyperStack.mem -> _: a -> Prims.GTot Type0 | {
"end_col": 15,
"end_line": 139,
"start_col": 2,
"start_line": 139
} | |
FStar.HyperStack.ST.ST | val rg_free (#a #rst: _) (rg: regional rst a) (v: a)
: HST.ST unit
(requires (fun h0 -> rg_inv rg h0 v))
(ensures (fun h0 _ h1 -> modifies (loc_all_regions_from false (Rgl?.region_of rg v)) h0 h1)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full... | false | let rg_free #a #rst (rg:regional rst a) (v:a)
: HST.ST unit
(requires (fun h0 -> rg_inv rg h0 v))
(ensures (fun h0 _ h1 ->
modifies (loc_all_regions_from false (Rgl?.region_of rg v)) h0 h1))
= (Rgl?.r_free rg) (Rgl?.state rg) v | val rg_free (#a #rst: _) (rg: regional rst a) (v: a)
: HST.ST unit
(requires (fun h0 -> rg_inv rg h0 v))
(ensures (fun h0 _ h1 -> modifies (loc_all_regions_from false (Rgl?.region_of rg v)) h0 h1))
let rg_free #a #rst (rg: regional rst a) (v: a)
: HST.ST unit
(requires (fun h0 -> rg_inv rg h0 ... | true | null | false | (Rgl?.r_free rg) (Rgl?.state rg) v | {
"checked_file": "LowStar.Regional.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Gho... | [] | [
"LowStar.Regional.regional",
"LowStar.Regional.__proj__Rgl__item__r_free",
"LowStar.Regional.__proj__Rgl__item__state",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Regional.rg_inv",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_all_regions_from",
"LowStar.Regional._... | [] | (*
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... | false | false | LowStar.Regional.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val rg_free (#a #rst: _) (rg: regional rst a) (v: a)
: HST.ST unit
(requires (fun h0 -> rg_inv rg h0 v))
(ensures (fun h0 _ h1 -> modifies (loc_all_regions_from false (Rgl?.region_of rg v)) h0 h1)) | [] | LowStar.Regional.rg_free | {
"file_name": "ulib/LowStar.Regional.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | rg: LowStar.Regional.regional rst a -> v: a -> FStar.HyperStack.ST.ST Prims.unit | {
"end_col": 36,
"end_line": 165,
"start_col": 2,
"start_line": 165
} |
FStar.HyperStack.ST.ST | val rg_alloc (#a #rst: _) (rg: regional rst a) (r: HST.erid)
: HST.ST a
(requires (fun h0 -> True))
(ensures
(fun h0 v h1 ->
Set.subset (Map.domain (HS.get_hmap h0)) (Map.domain (HS.get_hmap h1)) /\
modifies loc_none h0 h1 /\ fresh_loc (Rgl?.loc_of rg v) h0 h1 /\ (Rgl?.r_... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full... | false | let rg_alloc #a #rst (rg:regional rst a) (r:HST.erid)
: HST.ST a
(requires (fun h0 -> True))
(ensures (fun h0 v h1 ->
Set.subset (Map.domain (HS.get_hmap h0))
(Map.domain (HS.get_hmap h1)) /\
modifies loc_none h0 h1 /\
fresh_loc (Rgl?.loc_of rg v) h0 h1 /\
... | val rg_alloc (#a #rst: _) (rg: regional rst a) (r: HST.erid)
: HST.ST a
(requires (fun h0 -> True))
(ensures
(fun h0 v h1 ->
Set.subset (Map.domain (HS.get_hmap h0)) (Map.domain (HS.get_hmap h1)) /\
modifies loc_none h0 h1 /\ fresh_loc (Rgl?.loc_of rg v) h0 h1 /\ (Rgl?.r_... | true | null | false | Rgl?.r_alloc rg (Rgl?.state rg) r | {
"checked_file": "LowStar.Regional.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Gho... | [] | [
"LowStar.Regional.regional",
"FStar.HyperStack.ST.erid",
"LowStar.Regional.__proj__Rgl__item__r_alloc",
"LowStar.Regional.__proj__Rgl__item__state",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Prims.l_and",
"FStar.Set.subset",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Map.domain",
"FStar.Mo... | [] | (*
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... | false | false | LowStar.Regional.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val rg_alloc (#a #rst: _) (rg: regional rst a) (r: HST.erid)
: HST.ST a
(requires (fun h0 -> True))
(ensures
(fun h0 v h1 ->
Set.subset (Map.domain (HS.get_hmap h0)) (Map.domain (HS.get_hmap h1)) /\
modifies loc_none h0 h1 /\ fresh_loc (Rgl?.loc_of rg v) h0 h1 /\ (Rgl?.r_... | [] | LowStar.Regional.rg_alloc | {
"file_name": "ulib/LowStar.Regional.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | rg: LowStar.Regional.regional rst a -> r: FStar.HyperStack.ST.erid -> FStar.HyperStack.ST.ST a | {
"end_col": 35,
"end_line": 157,
"start_col": 2,
"start_line": 157
} |
Prims.Tot | val bitfield_eq64_lhs (x: U64.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 64}) : Tot U64.t | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let bitfield_eq64_lhs
(x: U64.t) (lo: nat) (hi: nat {lo <= hi /\ hi <= 64})
: Tot U64.t
= x `U64.logand` bitfield_mask64 lo hi | val bitfield_eq64_lhs (x: U64.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 64}) : Tot U64.t
let bitfield_eq64_lhs (x: U64.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 64}) : Tot U64.t = | false | null | false | x `U64.logand` (bitfield_mask64 lo hi) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt64.t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt64.logand",
"LowParse.BitFields.bitfield_mask64"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bitfield_eq64_lhs (x: U64.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 64}) : Tot U64.t | [] | LowParse.BitFields.bitfield_eq64_lhs | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt64.t -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= 64} -> FStar.UInt64.t | {
"end_col": 38,
"end_line": 927,
"start_col": 2,
"start_line": 927
} |
FStar.Pervasives.Lemma | val nth_pow2_minus_one (#n: pos) (m: nat{m <= n}) (i: nat{i < n})
: Lemma (requires True) (ensures (pow2 m <= pow2 n /\ (nth #n (pow2 m - 1) i == (i < m)))) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let nth_pow2_minus_one
(#n:pos)
(m:nat{m <= n})
(i:nat{i < n})
: Lemma (requires True)
(ensures (pow2 m <= pow2 n /\
(nth #n (pow2 m - 1) i == (i < m))))
= nth_pow2_minus_one' #n m (n - 1 - i) | val nth_pow2_minus_one (#n: pos) (m: nat{m <= n}) (i: nat{i < n})
: Lemma (requires True) (ensures (pow2 m <= pow2 n /\ (nth #n (pow2 m - 1) i == (i < m))))
let nth_pow2_minus_one (#n: pos) (m: nat{m <= n}) (i: nat{i < n})
: Lemma (requires True) (ensures (pow2 m <= pow2 n /\ (nth #n (pow2 m - 1) i == (i < m)))... | false | null | true | nth_pow2_minus_one' #n m (n - 1 - i) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.BitFields.nth_pow2_minus_one'",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_and",
"Prims.pow2",
"Prims.eq2",
"Prims.bool",
"LowParse.BitFields.nth",
"Pri... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val nth_pow2_minus_one (#n: pos) (m: nat{m <= n}) (i: nat{i < n})
: Lemma (requires True) (ensures (pow2 m <= pow2 n /\ (nth #n (pow2 m - 1) i == (i < m)))) | [] | LowParse.BitFields.nth_pow2_minus_one | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | m: Prims.nat{m <= n} -> i: Prims.nat{i < n}
-> FStar.Pervasives.Lemma
(ensures Prims.pow2 m <= Prims.pow2 n /\ LowParse.BitFields.nth (Prims.pow2 m - 1) i == (i < m)) | {
"end_col": 38,
"end_line": 78,
"start_col": 2,
"start_line": 78
} |
FStar.Pervasives.Lemma | val get_bitfield_empty
(#tot: pos)
(x: U.uint_t tot)
(i: nat { i <= tot })
: Lemma
(get_bitfield x i i == 0) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield_empty
(#tot: pos)
(x: U.uint_t tot)
(i: nat { i <= tot })
: Lemma
(get_bitfield x i i == 0)
= eq_nth (get_bitfield x i i) 0 (fun j ->
nth_get_bitfield x i i j;
nth_zero tot j
) | val get_bitfield_empty
(#tot: pos)
(x: U.uint_t tot)
(i: nat { i <= tot })
: Lemma
(get_bitfield x i i == 0)
let get_bitfield_empty (#tot: pos) (x: U.uint_t tot) (i: nat{i <= tot})
: Lemma (get_bitfield x i i == 0) = | false | null | true | eq_nth (get_bitfield x i i)
0
(fun j ->
nth_get_bitfield x i i j;
nth_zero tot j) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.eq_nth",
"LowParse.BitFields.get_bitfield",
"Prims.op_LessThan",
"LowParse.BitFields.nth_zero",
"Prims.unit",
"LowParse.BitFields.nth_get_bitfield",
"Prims.l_True",
"Prims.squash",
"... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_empty
(#tot: pos)
(x: U.uint_t tot)
(i: nat { i <= tot })
: Lemma
(get_bitfield x i i == 0) | [] | LowParse.BitFields.get_bitfield_empty | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt.uint_t tot -> i: Prims.nat{i <= tot}
-> FStar.Pervasives.Lemma (ensures LowParse.BitFields.get_bitfield x i i == 0) | {
"end_col": 3,
"end_line": 442,
"start_col": 2,
"start_line": 439
} |
Prims.Tot | val nth (#n: pos) (a: U.uint_t n) (i: nat{i < n}) : Tot bool | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let nth (#n: pos) (a: U.uint_t n) (i: nat {i < n}) : Tot bool =
U.nth a (n - 1 - i) | val nth (#n: pos) (a: U.uint_t n) (i: nat{i < n}) : Tot bool
let nth (#n: pos) (a: U.uint_t n) (i: nat{i < n}) : Tot bool = | false | null | false | U.nth a (n - 1 - i) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt.nth",
"Prims.op_Subtraction",
"Prims.bool"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val nth (#n: pos) (a: U.uint_t n) (i: nat{i < n}) : Tot bool | [] | LowParse.BitFields.nth | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | a: FStar.UInt.uint_t n -> i: Prims.nat{i < n} -> Prims.bool | {
"end_col": 21,
"end_line": 49,
"start_col": 2,
"start_line": 49
} |
Prims.Tot | val bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot}) : Tot (U.uint_t tot) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2 (hi - lo) - 1) * pow2 lo) | val bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot}) : Tot (U.uint_t tot)
let bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot}) : Tot (U.uint_t tot) = | false | null | false | [@@ inline_let ]let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2 (hi - lo) - 1) * pow2 lo) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"Prims.pos",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Pervasives.normalize_term",
"FStar.UInt.uint_t",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.unit",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.pow2_le_compat"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot}) : Tot (U.uint_t tot) | [] | LowParse.BitFields.bitfield_mask | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | tot: Prims.pos -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot} -> FStar.UInt.uint_t tot | {
"end_col": 49,
"end_line": 13,
"start_col": 2,
"start_line": 9
} |
FStar.Pervasives.Lemma | val get_bitfield_zero
(tot: pos)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot })
: Lemma
(get_bitfield #tot 0 lo hi == 0) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield_zero
(tot: pos)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot })
: Lemma
(get_bitfield #tot 0 lo hi == 0)
= eq_nth (get_bitfield #tot 0 lo hi) 0 (fun i ->
nth_zero tot i;
nth_get_bitfield #tot 0 lo hi i;
if i < hi - lo
then nth_zero tot (i + lo)
) | val get_bitfield_zero
(tot: pos)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot })
: Lemma
(get_bitfield #tot 0 lo hi == 0)
let get_bitfield_zero (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma (get_bitfield #tot 0 lo hi == 0) = | false | null | true | eq_nth (get_bitfield #tot 0 lo hi)
0
(fun i ->
nth_zero tot i;
nth_get_bitfield #tot 0 lo hi i;
if i < hi - lo then nth_zero tot (i + lo)) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.eq_nth",
"LowParse.BitFields.get_bitfield",
"Prims.op_LessThan",
"Prims.op_Subtraction",
"LowParse.BitFields.nth_zero",
"Prims.op_Addition",
"Prims.bool",
"Prims.unit",
"LowParse.BitFields... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_zero
(tot: pos)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot })
: Lemma
(get_bitfield #tot 0 lo hi == 0) | [] | LowParse.BitFields.get_bitfield_zero | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | tot: Prims.pos -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot}
-> FStar.Pervasives.Lemma (ensures LowParse.BitFields.get_bitfield 0 lo hi == 0) | {
"end_col": 3,
"end_line": 422,
"start_col": 2,
"start_line": 417
} |
FStar.Pervasives.Lemma | val set_bitfield_empty
(#tot: pos) (x: U.uint_t tot) (i: nat { i <= tot }) (y: ubitfield tot 0)
: Lemma
(set_bitfield x i i y == x) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let set_bitfield_empty
(#tot: pos) (x: U.uint_t tot) (i: nat { i <= tot }) (y: ubitfield tot 0)
: Lemma
(set_bitfield x i i y == x)
= eq_nth (set_bitfield x i i y) x (fun j ->
nth_set_bitfield x i i y j
) | val set_bitfield_empty
(#tot: pos) (x: U.uint_t tot) (i: nat { i <= tot }) (y: ubitfield tot 0)
: Lemma
(set_bitfield x i i y == x)
let set_bitfield_empty (#tot: pos) (x: U.uint_t tot) (i: nat{i <= tot}) (y: ubitfield tot 0)
: Lemma (set_bitfield x i i y == x) = | false | null | true | eq_nth (set_bitfield x i i y) x (fun j -> nth_set_bitfield x i i y j) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.ubitfield",
"LowParse.BitFields.eq_nth",
"LowParse.BitFields.set_bitfield",
"Prims.op_LessThan",
"LowParse.BitFields.nth_set_bitfield",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val set_bitfield_empty
(#tot: pos) (x: U.uint_t tot) (i: nat { i <= tot }) (y: ubitfield tot 0)
: Lemma
(set_bitfield x i i y == x) | [] | LowParse.BitFields.set_bitfield_empty | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt.uint_t tot -> i: Prims.nat{i <= tot} -> y: LowParse.BitFields.ubitfield tot 0
-> FStar.Pervasives.Lemma (ensures LowParse.BitFields.set_bitfield x i i y == x) | {
"end_col": 3,
"end_line": 403,
"start_col": 2,
"start_line": 401
} |
FStar.Pervasives.Lemma | val get_bitfield_raw_eq_logand_pow2_hi_lo_minus_one
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
: Lemma
(let y = get_bitfield_raw x lo hi in
pow2 (hi - lo) - 1 < pow2 tot /\ y == y `U.logand` (pow2 (hi - lo) - 1)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield_raw_eq_logand_pow2_hi_lo_minus_one (#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot}) : Lemma
(let y = get_bitfield_raw x lo hi in
pow2 (hi - lo) - 1 < pow2 tot /\
y == y `U.logand` (pow2 (hi - lo) - 1)
)
= nth_pow2_minus_one #tot (hi - lo) 0;
let y = get_bitfield_r... | val get_bitfield_raw_eq_logand_pow2_hi_lo_minus_one
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
: Lemma
(let y = get_bitfield_raw x lo hi in
pow2 (hi - lo) - 1 < pow2 tot /\ y == y `U.logand` (pow2 (hi - lo) - 1))
let get_bitfield_raw_eq_logand_pow2_hi_... | false | null | true | nth_pow2_minus_one #tot (hi - lo) 0;
let y = get_bitfield_raw x lo hi in
eq_nth y
(y `U.logand` (pow2 (hi - lo) - 1))
(fun i ->
nth_get_bitfield_raw x lo hi i;
nth_pow2_minus_one #tot (hi - lo) i;
nth_logand y (pow2 (hi - lo) - 1) i) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.eq_nth",
"FStar.UInt.logand",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_LessThan",
"LowParse.BitFields.nth_logand",
"Prims.unit",
"LowParse.BitFields.nth_pow2_mi... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_raw_eq_logand_pow2_hi_lo_minus_one
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
: Lemma
(let y = get_bitfield_raw x lo hi in
pow2 (hi - lo) - 1 < pow2 tot /\ y == y `U.logand` (pow2 (hi - lo) - 1)) | [] | LowParse.BitFields.get_bitfield_raw_eq_logand_pow2_hi_lo_minus_one | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt.uint_t tot -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot}
-> FStar.Pervasives.Lemma
(ensures
(let y = LowParse.BitFields.get_bitfield_raw x lo hi in
Prims.pow2 (hi - lo) - 1 < Prims.pow2 tot /\
y == FStar.UInt.logand y (Prims.pow2 (hi - lo) - 1))) | {
"end_col": 3,
"end_line": 156,
"start_col": 2,
"start_line": 150
} |
Prims.Tot | val not_bitfield_mask64 (lo: nat) (hi: nat{lo <= hi /\ hi <= 64})
: Tot (x: U64.t{U64.v x == not_bitfield_mask 64 lo hi}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let not_bitfield_mask64 (lo: nat) (hi: nat { lo <= hi /\ hi <= 64 }) : Tot (x: U64.t { U64.v x == not_bitfield_mask 64 lo hi }) =
U64.lognot (bitfield_mask64 lo hi) | val not_bitfield_mask64 (lo: nat) (hi: nat{lo <= hi /\ hi <= 64})
: Tot (x: U64.t{U64.v x == not_bitfield_mask 64 lo hi})
let not_bitfield_mask64 (lo: nat) (hi: nat{lo <= hi /\ hi <= 64})
: Tot (x: U64.t{U64.v x == not_bitfield_mask 64 lo hi}) = | false | null | false | U64.lognot (bitfield_mask64 lo hi) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt64.lognot",
"LowParse.BitFields.bitfield_mask64",
"FStar.UInt64.t",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt64.v",
"LowParse.BitFields.not_bitfield_mask"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val not_bitfield_mask64 (lo: nat) (hi: nat{lo <= hi /\ hi <= 64})
: Tot (x: U64.t{U64.v x == not_bitfield_mask 64 lo hi}) | [] | LowParse.BitFields.not_bitfield_mask64 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= 64}
-> x: FStar.UInt64.t{FStar.UInt64.v x == LowParse.BitFields.not_bitfield_mask 64 lo hi} | {
"end_col": 36,
"end_line": 907,
"start_col": 2,
"start_line": 907
} |
FStar.Pervasives.Lemma | val set_bitfield_eq
(#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
: Lemma
(set_bitfield x lo hi v == (x `U.logand` U.lognot ((U.lognot 0 `U.shift_right` (tot - (hi - lo))) `U.shift_left` lo)) `U.logor` (v `U.shift_left` lo)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let set_bitfield_eq
(#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
: Lemma
(set_bitfield x lo hi v == (x `U.logand` U.lognot ((U.lognot 0 `U.shift_right` (tot - (hi - lo))) `U.shift_left` lo)) `U.logor` (v `U.shift_left` lo))
= bitfield_mask_eq_2 tot lo hi | val set_bitfield_eq
(#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
: Lemma
(set_bitfield x lo hi v == (x `U.logand` U.lognot ((U.lognot 0 `U.shift_right` (tot - (hi - lo))) `U.shift_left` lo)) `U.logor` (v `U.shift_left` lo))
let set_bitfield_eq
(#tot:... | false | null | true | bitfield_mask_eq_2 tot lo hi | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.ubitfield",
"Prims.op_Subtraction",
"LowParse.BitFields.bitfield_mask_eq_2",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"LowParse.BitFields.set_bitfiel... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val set_bitfield_eq
(#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
: Lemma
(set_bitfield x lo hi v == (x `U.logand` U.lognot ((U.lognot 0 `U.shift_right` (tot - (hi - lo))) `U.shift_left` lo)) `U.logor` (v `U.shift_left` lo)) | [] | LowParse.BitFields.set_bitfield_eq | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt.uint_t tot ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot} ->
v: LowParse.BitFields.ubitfield tot (hi - lo)
-> FStar.Pervasives.Lemma
(ensures
LowParse.BitFields.set_bitfield x lo hi v ==
FStar.UInt.logor (FStar.UInt.logand x
(FStar.UInt.lognot (FSta... | {
"end_col": 30,
"end_line": 872,
"start_col": 2,
"start_line": 872
} |
FStar.Pervasives.Lemma | val bitfield_mask_lt_pow2_hi (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma (bitfield_mask tot lo hi < pow2 hi) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let bitfield_mask_lt_pow2_hi
(tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot })
: Lemma
(bitfield_mask tot lo hi < pow2 hi)
=
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo | val bitfield_mask_lt_pow2_hi (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma (bitfield_mask tot lo hi < pow2 hi)
let bitfield_mask_lt_pow2_hi (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma (bitfield_mask tot lo hi < pow2 hi) = | false | null | true | M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Math.Lemmas.pow2_plus",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.Math.Lemmas.pow2_le_compat",
"Prims.l_True",
"Prims.squash",
"Prims.op_LessThan",
"LowParse.BitFields.bitfield_mask",
"Prims.pow2",
... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bitfield_mask_lt_pow2_hi (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma (bitfield_mask tot lo hi < pow2 hi) | [] | LowParse.BitFields.bitfield_mask_lt_pow2_hi | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | tot: Prims.pos -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot}
-> FStar.Pervasives.Lemma (ensures LowParse.BitFields.bitfield_mask tot lo hi < Prims.pow2 hi) | {
"end_col": 28,
"end_line": 270,
"start_col": 4,
"start_line": 269
} |
FStar.Pervasives.Lemma | val get_bitfield_eq
(#tot: pos)
(x: U.uint_t tot)
(lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Lemma
(get_bitfield x lo hi == (x / pow2 lo) % pow2 (hi - lo)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield_eq (#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot}) : Lemma
(get_bitfield x lo hi == (x / pow2 lo) % pow2 (hi - lo))
= if hi - lo = 0
then begin
assert (hi == lo);
assert_norm (pow2 0 == 1);
mod_1 (x / pow2 lo);
get_bitfield_empty #tot x lo
end else if hi... | val get_bitfield_eq
(#tot: pos)
(x: U.uint_t tot)
(lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Lemma
(get_bitfield x lo hi == (x / pow2 lo) % pow2 (hi - lo))
let get_bitfield_eq (#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma (get_bitfield x lo hi == (x / pow2 lo) % pow2 (h... | false | null | true | if hi - lo = 0
then
(assert (hi == lo);
assert_norm (pow2 0 == 1);
mod_1 (x / pow2 lo);
get_bitfield_empty #tot x lo)
else
if hi - lo = tot
then
(assert (hi == tot);
assert (lo == 0);
assert_norm (pow2 0 == 1);
div_1 x;
M.small_mod x (pow2 tot);
get_bitfield_full #tot... | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Subtraction",
"LowParse.BitFields.get_bitfield_empty",
"Prims.unit",
"LowParse.BitFields.mod_1",
"Prims.op_Division",
"Prims.pow2",
"FStar.Pe... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_eq
(#tot: pos)
(x: U.uint_t tot)
(lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Lemma
(get_bitfield x lo hi == (x / pow2 lo) % pow2 (hi - lo)) | [] | LowParse.BitFields.get_bitfield_eq | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt.uint_t tot -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot}
-> FStar.Pervasives.Lemma
(ensures LowParse.BitFields.get_bitfield x lo hi == x / Prims.pow2 lo % Prims.pow2 (hi - lo)) | {
"end_col": 5,
"end_line": 832,
"start_col": 2,
"start_line": 811
} |
FStar.Pervasives.Lemma | val get_bitfield_set_bitfield_other
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
(lo' : nat) (hi' : nat { lo' <= hi' /\ hi' <= tot })
: Lemma
(requires (hi' <= lo \/ hi <= lo'))
(ensures (get_bitfield (set_bitfield x lo hi v) lo' hi' == get_bitfield ... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield_set_bitfield_other
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
(lo' : nat) (hi' : nat { lo' <= hi' /\ hi' <= tot })
: Lemma
(requires (hi' <= lo \/ hi <= lo'))
(ensures (get_bitfield (set_bitfield x lo hi v) lo' hi' == get_bitfield ... | val get_bitfield_set_bitfield_other
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
(lo' : nat) (hi' : nat { lo' <= hi' /\ hi' <= tot })
: Lemma
(requires (hi' <= lo \/ hi <= lo'))
(ensures (get_bitfield (set_bitfield x lo hi v) lo' hi' == get_bitfield ... | false | null | true | eq_nth (get_bitfield (set_bitfield x lo hi v) lo' hi')
(get_bitfield x lo' hi')
(fun i ->
nth_get_bitfield (set_bitfield x lo hi v) lo' hi' i;
nth_get_bitfield x lo' hi' i;
if i < hi' - lo' then nth_set_bitfield x lo hi v (i + lo')) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.ubitfield",
"Prims.op_Subtraction",
"LowParse.BitFields.eq_nth",
"LowParse.BitFields.get_bitfield",
"LowParse.BitFields.set_bitfield",
"Prims.op_LessThan",
"LowParse.Bit... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_set_bitfield_other
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
(lo' : nat) (hi' : nat { lo' <= hi' /\ hi' <= tot })
: Lemma
(requires (hi' <= lo \/ hi <= lo'))
(ensures (get_bitfield (set_bitfield x lo hi v) lo' hi' == get_bitfield ... | [] | LowParse.BitFields.get_bitfield_set_bitfield_other | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt.uint_t tot ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot} ->
v: LowParse.BitFields.ubitfield tot (hi - lo) ->
lo': Prims.nat ->
hi': Prims.nat{lo' <= hi' /\ hi' <= tot}
-> FStar.Pervasives.Lemma (requires hi' <= lo \/ hi <= lo')
(ensures
LowParse.BitField... | {
"end_col": 3,
"end_line": 360,
"start_col": 2,
"start_line": 353
} |
FStar.Pervasives.Lemma | val get_bitfield_partition'
(#tot: pos)
(x y: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(l: list nat)
: Lemma (requires (get_bitfield_partition_prop x y lo hi l))
(ensures (get_bitfield x lo hi == get_bitfield y lo hi))
(decreases l) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let rec get_bitfield_partition'
(#tot: pos)
(x y: U.uint_t tot)
(lo: nat)
(hi: nat { lo <= hi /\ hi <= tot })
(l: list nat)
: Lemma
(requires (get_bitfield_partition_prop x y lo hi l))
(ensures (get_bitfield x lo hi == get_bitfield y lo hi))
(decreases l)
= match l with
| [] -> ()
| mi :: q ->
g... | val get_bitfield_partition'
(#tot: pos)
(x y: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(l: list nat)
: Lemma (requires (get_bitfield_partition_prop x y lo hi l))
(ensures (get_bitfield x lo hi == get_bitfield y lo hi))
(decreases l)
let rec get_bitfield_part... | false | null | true | match l with
| [] -> ()
| mi :: q ->
get_bitfield_partition' x y mi hi q;
get_bitfield_partition_2_gen lo mi hi x y | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma",
""
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.list",
"LowParse.BitFields.get_bitfield_partition_2_gen",
"Prims.unit",
"LowParse.BitFields.get_bitfield_partition'",
"LowParse.BitFields.get_bitfield_partition_prop",
"Prims.squash",
... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_partition'
(#tot: pos)
(x y: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(l: list nat)
: Lemma (requires (get_bitfield_partition_prop x y lo hi l))
(ensures (get_bitfield x lo hi == get_bitfield y lo hi))
(decreases l) | [
"recursion"
] | LowParse.BitFields.get_bitfield_partition' | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt.uint_t tot ->
y: FStar.UInt.uint_t tot ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot} ->
l: Prims.list Prims.nat
-> FStar.Pervasives.Lemma (requires LowParse.BitFields.get_bitfield_partition_prop x y lo hi l)
(ensures LowParse.BitFields.get_bitfield x lo hi == LowPar... | {
"end_col": 45,
"end_line": 694,
"start_col": 2,
"start_line": 690
} |
FStar.Pervasives.Lemma | val nth_set_bitfield
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(v: ubitfield tot (hi - lo))
(i: nat{i < tot})
: Lemma
(nth (set_bitfield x lo hi v) i == (if lo <= i && i < hi then nth v (i - lo) else nth x i)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let nth_set_bitfield
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
(i: nat {i < tot})
: Lemma
(nth (set_bitfield x lo hi v) i == (if lo <= i && i < hi then nth v (i - lo) else nth x i))
=
let y = nth (set_bitfield x lo hi v) i in
nth_logor (x `U.log... | val nth_set_bitfield
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(v: ubitfield tot (hi - lo))
(i: nat{i < tot})
: Lemma
(nth (set_bitfield x lo hi v) i == (if lo <= i && i < hi then nth v (i - lo) else nth x i))
let nth_set_bitfield
(#tot: p... | false | null | true | let y = nth (set_bitfield x lo hi v) i in
nth_logor (x `U.logand` (not_bitfield_mask tot lo hi)) (v `U.shift_left` lo) i;
assert (y == (nth (x `U.logand` (not_bitfield_mask tot lo hi)) i || nth (v `U.shift_left` lo) i));
nth_logand x (not_bitfield_mask tot lo hi) i;
assert (y == ((nth x i && nth (not_bitfield_mask tot ... | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.ubitfield",
"Prims.op_Subtraction",
"Prims.op_LessThan",
"Prims._assert",
"Prims.eq2",
"Prims.bool",
"Prims.op_AmpAmp",
"LowParse.BitFields.nth",
"Prims.unit",
"Lo... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val nth_set_bitfield
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(v: ubitfield tot (hi - lo))
(i: nat{i < tot})
: Lemma
(nth (set_bitfield x lo hi v) i == (if lo <= i && i < hi then nth v (i - lo) else nth x i)) | [] | LowParse.BitFields.nth_set_bitfield | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt.uint_t tot ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot} ->
v: LowParse.BitFields.ubitfield tot (hi - lo) ->
i: Prims.nat{i < tot}
-> FStar.Pervasives.Lemma
(ensures
LowParse.BitFields.nth (LowParse.BitFields.set_bitfield x lo hi v) i ==
(match lo <= i && ... | {
"end_col": 71,
"end_line": 328,
"start_col": 1,
"start_line": 309
} |
FStar.Pervasives.Lemma | val pow2_m_minus_one_eq (n m: nat)
: Lemma (requires (m <= n)) (ensures ((pow2 n - 1) / pow2 m == pow2 (n - m) - 1)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let pow2_m_minus_one_eq
(n: nat)
(m: nat)
: Lemma
(requires (m <= n))
(ensures (
(pow2 n - 1) / pow2 m == pow2 (n - m) - 1
))
= M.pow2_le_compat n m;
M.pow2_plus (n - m) m;
M.division_definition (pow2 n - 1) (pow2 m) (pow2 (n - m) - 1) | val pow2_m_minus_one_eq (n m: nat)
: Lemma (requires (m <= n)) (ensures ((pow2 n - 1) / pow2 m == pow2 (n - m) - 1))
let pow2_m_minus_one_eq (n m: nat)
: Lemma (requires (m <= n)) (ensures ((pow2 n - 1) / pow2 m == pow2 (n - m) - 1)) = | false | null | true | M.pow2_le_compat n m;
M.pow2_plus (n - m) m;
M.division_definition (pow2 n - 1) (pow2 m) (pow2 (n - m) - 1) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.nat",
"FStar.Math.Lemmas.division_definition",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.unit",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.pow2_le_compat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"Prims.op_Division",
"Prims.Nil",
... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pow2_m_minus_one_eq (n m: nat)
: Lemma (requires (m <= n)) (ensures ((pow2 n - 1) / pow2 m == pow2 (n - m) - 1)) | [] | LowParse.BitFields.pow2_m_minus_one_eq | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | n: Prims.nat -> m: Prims.nat
-> FStar.Pervasives.Lemma (requires m <= n)
(ensures (Prims.pow2 n - 1) / Prims.pow2 m == Prims.pow2 (n - m) - 1) | {
"end_col": 64,
"end_line": 844,
"start_col": 2,
"start_line": 842
} |
Prims.Tot | val get_bitfield64 (x: U64.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 64})
: Tot (y: U64.t{U64.v y == get_bitfield (U64.v x) lo hi}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let get_bitfield64
(x: U64.t) (lo: nat) (hi: nat {lo <= hi /\ hi <= 64})
: Tot (y: U64.t { U64.v y == get_bitfield (U64.v x) lo hi })
= (x `U64.logand` bitfield_mask64 lo hi) `u64_shift_right` (U32.uint_to_t lo) | val get_bitfield64 (x: U64.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 64})
: Tot (y: U64.t{U64.v y == get_bitfield (U64.v x) lo hi})
let get_bitfield64 (x: U64.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 64})
: Tot (y: U64.t{U64.v y == get_bitfield (U64.v x) lo hi}) = | false | null | false | (x `U64.logand` (bitfield_mask64 lo hi)) `u64_shift_right` (U32.uint_to_t lo) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt64.t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.u64_shift_right",
"FStar.UInt64.logand",
"LowParse.BitFields.bitfield_mask64",
"FStar.UInt32.uint_to_t",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt64.n",
"FStar.UInt64.v",
"LowPars... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield64 (x: U64.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 64})
: Tot (y: U64.t{U64.v y == get_bitfield (U64.v x) lo hi}) | [] | LowParse.BitFields.get_bitfield64 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt64.t -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= 64}
-> y: FStar.UInt64.t{FStar.UInt64.v y == LowParse.BitFields.get_bitfield (FStar.UInt64.v x) lo hi} | {
"end_col": 77,
"end_line": 903,
"start_col": 2,
"start_line": 903
} |
Prims.Tot | val not_bitfield_mask8 (lo: nat) (hi: nat{lo <= hi /\ hi <= 8})
: Tot (x: U8.t{U8.v x == not_bitfield_mask 8 lo hi}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let not_bitfield_mask8 (lo: nat) (hi: nat { lo <= hi /\ hi <= 8 }) : Tot (x: U8.t { U8.v x == not_bitfield_mask 8 lo hi }) =
U8.lognot (bitfield_mask8 lo hi) | val not_bitfield_mask8 (lo: nat) (hi: nat{lo <= hi /\ hi <= 8})
: Tot (x: U8.t{U8.v x == not_bitfield_mask 8 lo hi})
let not_bitfield_mask8 (lo: nat) (hi: nat{lo <= hi /\ hi <= 8})
: Tot (x: U8.t{U8.v x == not_bitfield_mask 8 lo hi}) = | false | null | false | U8.lognot (bitfield_mask8 lo hi) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt8.lognot",
"LowParse.BitFields.bitfield_mask8",
"FStar.UInt8.t",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt8.v",
"LowParse.BitFields.not_bitfield_mask"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val not_bitfield_mask8 (lo: nat) (hi: nat{lo <= hi /\ hi <= 8})
: Tot (x: U8.t{U8.v x == not_bitfield_mask 8 lo hi}) | [] | LowParse.BitFields.not_bitfield_mask8 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= 8}
-> x: FStar.UInt8.t{FStar.UInt8.v x == LowParse.BitFields.not_bitfield_mask 8 lo hi} | {
"end_col": 34,
"end_line": 1164,
"start_col": 2,
"start_line": 1164
} |
Prims.Tot | val uint64 : uint_t 64 U64.t | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let uint64 : uint_t 64 U64.t = {
v = U64.v;
uint_to_t = U64.uint_to_t;
v_uint_to_t = (fun _ -> ());
uint_to_t_v = (fun _ -> ());
get_bitfield_gen = (fun x lo hi -> get_bitfield_gen64 x lo hi);
set_bitfield_gen = (fun x lo hi z -> set_bitfield_gen64 x lo hi z);
get_bitfield = (fun x lo hi -> get_bitfield64... | val uint64 : uint_t 64 U64.t
let uint64:uint_t 64 U64.t = | false | null | false | {
v = U64.v;
uint_to_t = U64.uint_to_t;
v_uint_to_t = (fun _ -> ());
uint_to_t_v = (fun _ -> ());
get_bitfield_gen = (fun x lo hi -> get_bitfield_gen64 x lo hi);
set_bitfield_gen = (fun x lo hi z -> set_bitfield_gen64 x lo hi z);
get_bitfield = (fun x lo hi -> get_bitfield64 x lo hi);
set_bitfield = (fu... | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"LowParse.BitFields.Mkuint_t",
"FStar.UInt64.n",
"FStar.UInt64.t",
"FStar.UInt64.v",
"FStar.UInt64.uint_to_t",
"FStar.UInt.uint_t",
"Prims.unit",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt32.v",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.get_bitfiel... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val uint64 : uint_t 64 U64.t | [] | LowParse.BitFields.uint64 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | LowParse.BitFields.uint_t 64 FStar.UInt64.t | {
"end_col": 67,
"end_line": 1215,
"start_col": 2,
"start_line": 1205
} |
FStar.Pervasives.Lemma | val nth_pow2_minus_one' : #n:pos -> m:nat{m <= n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (pow2 m <= pow2 n /\
(i < n - m ==> U.nth #n (pow2 m - 1) i == false) /\
(n - m <= i ==> U.nth #n (pow2 m - 1) i == true))) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let rec nth_pow2_minus_one' #n m i =
let a = pow2 m - 1 in
M.pow2_le_compat n m;
if m = 0 then U.one_to_vec_lemma #n i
else if m = n then U.ones_to_vec_lemma #n i
else if i = n - 1 then ()
else nth_pow2_minus_one' #(n - 1) (m - 1) i | val nth_pow2_minus_one' : #n:pos -> m:nat{m <= n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (pow2 m <= pow2 n /\
(i < n - m ==> U.nth #n (pow2 m - 1) i == false) /\
(n - m <= i ==> U.nth #n (pow2 m - 1) i == true)))
let rec nth_pow2_minus_one' #n m i = | false | null | true | let a = pow2 m - 1 in
M.pow2_le_compat n m;
if m = 0
then U.one_to_vec_lemma #n i
else
if m = n
then U.ones_to_vec_lemma #n i
else if i = n - 1 then () else nth_pow2_minus_one' #(n - 1) (m - 1) i | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Equality",
"Prims.int",
"FStar.UInt.one_to_vec_lemma",
"Prims.bool",
"Prims.l_or",
"Prims.l_and",
"Prims.op_GreaterThanOrEqual",
"Prims.op_GreaterThan",
"FStar.UInt.ones_to_vec_lemma",
"Prim... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val nth_pow2_minus_one' : #n:pos -> m:nat{m <= n} -> i:nat{i < n} ->
Lemma (requires True)
(ensures (pow2 m <= pow2 n /\
(i < n - m ==> U.nth #n (pow2 m - 1) i == false) /\
(n - m <= i ==> U.nth #n (pow2 m - 1) i == true))) | [
"recursion"
] | LowParse.BitFields.nth_pow2_minus_one' | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | m: Prims.nat{m <= n} -> i: Prims.nat{i < n}
-> FStar.Pervasives.Lemma
(ensures
Prims.pow2 m <= Prims.pow2 n /\ (i < n - m ==> FStar.UInt.nth (Prims.pow2 m - 1) i == false) /\
(n - m <= i ==> FStar.UInt.nth (Prims.pow2 m - 1) i == true)) | {
"end_col": 46,
"end_line": 44,
"start_col": 36,
"start_line": 38
} |
Prims.Tot | val u32_shift_right (x: U32.t) (amount: U32.t{U32.v amount <= 32})
: Tot (y: U32.t{U32.v y == (U32.v x) `U.shift_right` (U32.v amount)}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let u32_shift_right
(x: U32.t)
(amount: U32.t { U32.v amount <= 32 })
: Tot (y: U32.t { U32.v y == U32.v x `U.shift_right` U32.v amount })
= if amount = 32ul then 0ul else x `U32.shift_right` amount | val u32_shift_right (x: U32.t) (amount: U32.t{U32.v amount <= 32})
: Tot (y: U32.t{U32.v y == (U32.v x) `U.shift_right` (U32.v amount)})
let u32_shift_right (x: U32.t) (amount: U32.t{U32.v amount <= 32})
: Tot (y: U32.t{U32.v y == (U32.v x) `U.shift_right` (U32.v amount)}) = | false | null | false | if amount = 32ul then 0ul else x `U32.shift_right` amount | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.op_Equality",
"FStar.UInt32.__uint_to_t",
"Prims.bool",
"FStar.UInt32.shift_right",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt32.n",
"FStar.UInt.shift_right"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val u32_shift_right (x: U32.t) (amount: U32.t{U32.v amount <= 32})
: Tot (y: U32.t{U32.v y == (U32.v x) `U.shift_right` (U32.v amount)}) | [] | LowParse.BitFields.u32_shift_right | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt32.t -> amount: FStar.UInt32.t{FStar.UInt32.v amount <= 32}
-> y:
FStar.UInt32.t
{FStar.UInt32.v y == FStar.UInt.shift_right (FStar.UInt32.v x) (FStar.UInt32.v amount)} | {
"end_col": 59,
"end_line": 974,
"start_col": 2,
"start_line": 974
} |
FStar.Pervasives.Lemma | val get_bitfield_size
(tot1 tot2: pos)
(x: nat { x < pow2 tot1 /\ tot1 <= tot2 })
(lo: nat)
(hi: nat { lo <= hi /\ hi <= tot1 })
: Lemma
(x < pow2 tot2 /\ (get_bitfield #tot1 x lo hi <: nat) == (get_bitfield #tot2 x lo hi <: nat)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield_size
(tot1 tot2: pos)
(x: nat { x < pow2 tot1 /\ tot1 <= tot2 })
(lo: nat)
(hi: nat { lo <= hi /\ hi <= tot1 })
: Lemma
(x < pow2 tot2 /\ (get_bitfield #tot1 x lo hi <: nat) == (get_bitfield #tot2 x lo hi <: nat))
= M.pow2_le_compat tot2 tot1;
eq_nth #tot2 (get_bitfield #tot1 x lo hi) (get_... | val get_bitfield_size
(tot1 tot2: pos)
(x: nat { x < pow2 tot1 /\ tot1 <= tot2 })
(lo: nat)
(hi: nat { lo <= hi /\ hi <= tot1 })
: Lemma
(x < pow2 tot2 /\ (get_bitfield #tot1 x lo hi <: nat) == (get_bitfield #tot2 x lo hi <: nat))
let get_bitfield_size
(tot1 tot2: pos)
(x: nat{x < pow2 tot1 /\ tot... | false | null | true | M.pow2_le_compat tot2 tot1;
eq_nth #tot2
(get_bitfield #tot1 x lo hi)
(get_bitfield #tot2 x lo hi)
(fun i ->
let y1 = nth #tot2 (get_bitfield #tot1 x lo hi) i in
let y2 = nth #tot2 (get_bitfield #tot2 x lo hi) i in
nth_get_bitfield #tot2 x lo hi i;
assert (y2 == (i < hi - lo && nth #tot2 x... | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.eq_nth",
"LowParse.BitFields.get_bitfield",
"Prims.op_Subtraction",
"LowParse.BitFields.nth_size",
"Prims.op_Addition",
"Prims.bool",
"Prims.unit",
"Pr... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_size
(tot1 tot2: pos)
(x: nat { x < pow2 tot1 /\ tot1 <= tot2 })
(lo: nat)
(hi: nat { lo <= hi /\ hi <= tot1 })
: Lemma
(x < pow2 tot2 /\ (get_bitfield #tot1 x lo hi <: nat) == (get_bitfield #tot2 x lo hi <: nat)) | [] | LowParse.BitFields.get_bitfield_size | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
tot1: Prims.pos ->
tot2: Prims.pos ->
x: Prims.nat{x < Prims.pow2 tot1 /\ tot1 <= tot2} ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot1}
-> FStar.Pervasives.Lemma
(ensures
x < Prims.pow2 tot2 /\
LowParse.BitFields.get_bitfield x lo hi == LowParse.BitFields.get_bitfield x ... | {
"end_col": 3,
"end_line": 730,
"start_col": 2,
"start_line": 715
} |
Prims.Tot | val get_bitfield32 (x: U32.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 32})
: Tot (y: U32.t{U32.v y == get_bitfield (U32.v x) lo hi}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let get_bitfield32
(x: U32.t) (lo: nat) (hi: nat {lo <= hi /\ hi <= 32})
: Tot (y: U32.t { U32.v y == get_bitfield (U32.v x) lo hi })
= (x `U32.logand` bitfield_mask32 lo hi) `u32_shift_right` (U32.uint_to_t lo) | val get_bitfield32 (x: U32.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 32})
: Tot (y: U32.t{U32.v y == get_bitfield (U32.v x) lo hi})
let get_bitfield32 (x: U32.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 32})
: Tot (y: U32.t{U32.v y == get_bitfield (U32.v x) lo hi}) = | false | null | false | (x `U32.logand` (bitfield_mask32 lo hi)) `u32_shift_right` (U32.uint_to_t lo) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt32.t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.u32_shift_right",
"FStar.UInt32.logand",
"LowParse.BitFields.bitfield_mask32",
"FStar.UInt32.uint_to_t",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt32.n",
"FStar.UInt32.v",
"LowPars... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield32 (x: U32.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 32})
: Tot (y: U32.t{U32.v y == get_bitfield (U32.v x) lo hi}) | [] | LowParse.BitFields.get_bitfield32 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt32.t -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= 32}
-> y: FStar.UInt32.t{FStar.UInt32.v y == LowParse.BitFields.get_bitfield (FStar.UInt32.v x) lo hi} | {
"end_col": 77,
"end_line": 980,
"start_col": 2,
"start_line": 980
} |
Prims.Tot | val uint8 : uint_t 8 U8.t | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let uint8 : uint_t 8 U8.t = {
v = U8.v;
uint_to_t = U8.uint_to_t;
v_uint_to_t = (fun _ -> ());
uint_to_t_v = (fun _ -> ());
get_bitfield_gen = (fun x lo hi -> get_bitfield_gen8 x lo hi);
set_bitfield_gen = (fun x lo hi z -> set_bitfield_gen8 x lo hi z);
get_bitfield = (fun x lo hi -> get_bitfield8 x lo hi... | val uint8 : uint_t 8 U8.t
let uint8:uint_t 8 U8.t = | false | null | false | {
v = U8.v;
uint_to_t = U8.uint_to_t;
v_uint_to_t = (fun _ -> ());
uint_to_t_v = (fun _ -> ());
get_bitfield_gen = (fun x lo hi -> get_bitfield_gen8 x lo hi);
set_bitfield_gen = (fun x lo hi z -> set_bitfield_gen8 x lo hi z);
get_bitfield = (fun x lo hi -> get_bitfield8 x lo hi);
set_bitfield = (fun x l... | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"LowParse.BitFields.Mkuint_t",
"FStar.UInt8.n",
"FStar.UInt8.t",
"FStar.UInt8.v",
"FStar.UInt8.uint_to_t",
"FStar.UInt.uint_t",
"Prims.unit",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt32.v",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.get_bitfield_ge... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val uint8 : uint_t 8 U8.t | [] | LowParse.BitFields.uint8 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | LowParse.BitFields.uint_t 8 FStar.UInt8.t | {
"end_col": 66,
"end_line": 1272,
"start_col": 2,
"start_line": 1262
} |
FStar.Pervasives.Lemma | val set_bitfield_size
(tot1 tot2: pos)
(x: nat { x < pow2 tot1 /\ tot1 <= tot2 })
(lo: nat)
(hi: nat { lo <= hi /\ hi <= tot1 })
(v: ubitfield tot1 (hi - lo))
: Lemma
(x < pow2 tot2 /\ v < pow2 tot2 /\ (set_bitfield #tot1 x lo hi v <: nat) == (set_bitfield #tot2 x lo hi v <: nat)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let set_bitfield_size
(tot1 tot2: pos)
(x: nat { x < pow2 tot1 /\ tot1 <= tot2 })
(lo: nat)
(hi: nat { lo <= hi /\ hi <= tot1 })
(v: ubitfield tot1 (hi - lo))
: Lemma
(x < pow2 tot2 /\ v < pow2 tot2 /\ (set_bitfield #tot1 x lo hi v <: nat) == (set_bitfield #tot2 x lo hi v <: nat))
= M.pow2_le_compat tot2 t... | val set_bitfield_size
(tot1 tot2: pos)
(x: nat { x < pow2 tot1 /\ tot1 <= tot2 })
(lo: nat)
(hi: nat { lo <= hi /\ hi <= tot1 })
(v: ubitfield tot1 (hi - lo))
: Lemma
(x < pow2 tot2 /\ v < pow2 tot2 /\ (set_bitfield #tot1 x lo hi v <: nat) == (set_bitfield #tot2 x lo hi v <: nat))
let set_bitfield_size
... | false | null | true | M.pow2_le_compat tot2 tot1;
eq_nth #tot2
(set_bitfield #tot1 x lo hi v)
(set_bitfield #tot2 x lo hi v)
(fun i ->
let y1 = nth #tot2 (set_bitfield #tot1 x lo hi v) i in
let y2 = nth #tot2 (set_bitfield #tot2 x lo hi v) i in
nth_set_bitfield #tot2 x lo hi v i;
nth_size tot1 tot2 (set_bitfiel... | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.ubitfield",
"Prims.op_Subtraction",
"LowParse.BitFields.eq_nth",
"LowParse.BitFields.set_bitfield",
"Prims.op_AmpAmp",
"LowParse.BitFields.nth_size",
"Pr... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val set_bitfield_size
(tot1 tot2: pos)
(x: nat { x < pow2 tot1 /\ tot1 <= tot2 })
(lo: nat)
(hi: nat { lo <= hi /\ hi <= tot1 })
(v: ubitfield tot1 (hi - lo))
: Lemma
(x < pow2 tot2 /\ v < pow2 tot2 /\ (set_bitfield #tot1 x lo hi v <: nat) == (set_bitfield #tot2 x lo hi v <: nat)) | [] | LowParse.BitFields.set_bitfield_size | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
tot1: Prims.pos ->
tot2: Prims.pos ->
x: Prims.nat{x < Prims.pow2 tot1 /\ tot1 <= tot2} ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot1} ->
v: LowParse.BitFields.ubitfield tot1 (hi - lo)
-> FStar.Pervasives.Lemma
(ensures
x < Prims.pow2 tot2 /\ v < Prims.pow2 tot2 /\
... | {
"end_col": 3,
"end_line": 753,
"start_col": 2,
"start_line": 740
} |
Prims.Tot | val bitfield_mask32 (lo: nat) (hi: nat{lo <= hi /\ hi <= 32})
: Tot (x: U32.t{U32.v x == bitfield_mask 32 lo hi}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let bitfield_mask32 (lo: nat) (hi: nat { lo <= hi /\ hi <= 32 }) : Tot (x: U32.t { U32.v x == bitfield_mask 32 lo hi }) =
if lo = hi
then 0ul
else begin
bitfield_mask_eq_2 32 lo hi;
(U32.lognot 0ul `U32.shift_right` (32ul `U32.sub` (U32.uint_to_t (hi - lo)))) `U32.shift_left` U32.uint_to_t lo
end | val bitfield_mask32 (lo: nat) (hi: nat{lo <= hi /\ hi <= 32})
: Tot (x: U32.t{U32.v x == bitfield_mask 32 lo hi})
let bitfield_mask32 (lo: nat) (hi: nat{lo <= hi /\ hi <= 32})
: Tot (x: U32.t{U32.v x == bitfield_mask 32 lo hi}) = | false | null | false | if lo = hi
then 0ul
else
(bitfield_mask_eq_2 32 lo hi;
((U32.lognot 0ul) `U32.shift_right` (32ul `U32.sub` (U32.uint_to_t (hi - lo))))
`U32.shift_left`
(U32.uint_to_t lo)) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"FStar.UInt32.__uint_to_t",
"Prims.bool",
"FStar.UInt32.shift_left",
"FStar.UInt32.shift_right",
"FStar.UInt32.lognot",
"FStar.UInt32.sub",
"FStar.UInt32.uint_to_t",
"Prims.op_Subtraction",
"Prims.uni... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bitfield_mask32 (lo: nat) (hi: nat{lo <= hi /\ hi <= 32})
: Tot (x: U32.t{U32.v x == bitfield_mask 32 lo hi}) | [] | LowParse.BitFields.bitfield_mask32 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= 32}
-> x: FStar.UInt32.t{FStar.UInt32.v x == LowParse.BitFields.bitfield_mask 32 lo hi} | {
"end_col": 5,
"end_line": 967,
"start_col": 2,
"start_line": 962
} |
Prims.Tot | val u16_shift_left (x: U16.t) (amount: U32.t{U32.v amount <= 16})
: Tot (y: U16.t{U16.v y == (U16.v x) `U.shift_left` (U32.v amount)}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let u16_shift_left
(x: U16.t)
(amount: U32.t { U32.v amount <= 16 })
: Tot (y: U16.t { U16.v y == U16.v x `U.shift_left` U32.v amount })
= if amount = 16ul then 0us else x `U16.shift_left` amount | val u16_shift_left (x: U16.t) (amount: U32.t{U32.v amount <= 16})
: Tot (y: U16.t{U16.v y == (U16.v x) `U.shift_left` (U32.v amount)})
let u16_shift_left (x: U16.t) (amount: U32.t{U32.v amount <= 16})
: Tot (y: U16.t{U16.v y == (U16.v x) `U.shift_left` (U32.v amount)}) = | false | null | false | if amount = 16ul then 0us else x `U16.shift_left` amount | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt16.t",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.op_Equality",
"FStar.UInt32.__uint_to_t",
"FStar.UInt16.__uint_to_t",
"Prims.bool",
"FStar.UInt16.shift_left",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt16.n",
"FStar.UInt16.v",
"FSta... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val u16_shift_left (x: U16.t) (amount: U32.t{U32.v amount <= 16})
: Tot (y: U16.t{U16.v y == (U16.v x) `U.shift_left` (U32.v amount)}) | [] | LowParse.BitFields.u16_shift_left | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt16.t -> amount: FStar.UInt32.t{FStar.UInt32.v amount <= 16}
-> y:
FStar.UInt16.t
{FStar.UInt16.v y == FStar.UInt.shift_left (FStar.UInt16.v x) (FStar.UInt32.v amount)} | {
"end_col": 58,
"end_line": 1068,
"start_col": 2,
"start_line": 1068
} |
Prims.Tot | val u16_shift_right (x: U16.t) (amount: U32.t{U32.v amount <= 16})
: Tot (y: U16.t{U16.v y == (U16.v x) `U.shift_right` (U32.v amount)}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let u16_shift_right
(x: U16.t)
(amount: U32.t { U32.v amount <= 16 })
: Tot (y: U16.t { U16.v y == U16.v x `U.shift_right` U32.v amount })
= if amount = 16ul then 0us else x `U16.shift_right` amount | val u16_shift_right (x: U16.t) (amount: U32.t{U32.v amount <= 16})
: Tot (y: U16.t{U16.v y == (U16.v x) `U.shift_right` (U32.v amount)})
let u16_shift_right (x: U16.t) (amount: U32.t{U32.v amount <= 16})
: Tot (y: U16.t{U16.v y == (U16.v x) `U.shift_right` (U32.v amount)}) = | false | null | false | if amount = 16ul then 0us else x `U16.shift_right` amount | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt16.t",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.op_Equality",
"FStar.UInt32.__uint_to_t",
"FStar.UInt16.__uint_to_t",
"Prims.bool",
"FStar.UInt16.shift_right",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt16.n",
"FStar.UInt16.v",
"FSt... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val u16_shift_right (x: U16.t) (amount: U32.t{U32.v amount <= 16})
: Tot (y: U16.t{U16.v y == (U16.v x) `U.shift_right` (U32.v amount)}) | [] | LowParse.BitFields.u16_shift_right | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt16.t -> amount: FStar.UInt32.t{FStar.UInt32.v amount <= 16}
-> y:
FStar.UInt16.t
{FStar.UInt16.v y == FStar.UInt.shift_right (FStar.UInt16.v x) (FStar.UInt32.v amount)} | {
"end_col": 59,
"end_line": 1051,
"start_col": 2,
"start_line": 1051
} |
Prims.Tot | val u8_shift_right (x: U8.t) (amount: U32.t{U32.v amount <= 8})
: Tot (y: U8.t{U8.v y == (U8.v x) `U.shift_right` (U32.v amount)}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let u8_shift_right
(x: U8.t)
(amount: U32.t { U32.v amount <= 8 })
: Tot (y: U8.t { U8.v y == U8.v x `U.shift_right` U32.v amount })
= let y =
if amount = 8ul then 0uy else x `U8.shift_right` amount
in
y | val u8_shift_right (x: U8.t) (amount: U32.t{U32.v amount <= 8})
: Tot (y: U8.t{U8.v y == (U8.v x) `U.shift_right` (U32.v amount)})
let u8_shift_right (x: U8.t) (amount: U32.t{U32.v amount <= 8})
: Tot (y: U8.t{U8.v y == (U8.v x) `U.shift_right` (U32.v amount)}) = | false | null | false | let y = if amount = 8ul then 0uy else x `U8.shift_right` amount in
y | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt8.t",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt8.v",
"FStar.UInt.shift_right",
"Prims.op_Equality",
"FStar.UInt32.__uint_to_t",
"FStar.UInt8.__uint_to_t",
"Prims.bool",
"FStar.UInt8.shift_right",
... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val u8_shift_right (x: U8.t) (amount: U32.t{U32.v amount <= 8})
: Tot (y: U8.t{U8.v y == (U8.v x) `U.shift_right` (U32.v amount)}) | [] | LowParse.BitFields.u8_shift_right | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt8.t -> amount: FStar.UInt32.t{FStar.UInt32.v amount <= 8}
-> y:
FStar.UInt8.t
{FStar.UInt8.v y == FStar.UInt.shift_right (FStar.UInt8.v x) (FStar.UInt32.v amount)} | {
"end_col": 3,
"end_line": 1127,
"start_col": 1,
"start_line": 1124
} |
Prims.Tot | val u8_shift_left (x: U8.t) (amount: U32.t{U32.v amount <= 8})
: Tot (y: U8.t{U8.v y == (U8.v x) `U.shift_left` (U32.v amount)}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let u8_shift_left
(x: U8.t)
(amount: U32.t { U32.v amount <= 8 })
: Tot (y: U8.t { U8.v y == U8.v x `U.shift_left` U32.v amount })
= let y =
if amount = 8ul then 0uy else x `U8.shift_left` amount
in
y | val u8_shift_left (x: U8.t) (amount: U32.t{U32.v amount <= 8})
: Tot (y: U8.t{U8.v y == (U8.v x) `U.shift_left` (U32.v amount)})
let u8_shift_left (x: U8.t) (amount: U32.t{U32.v amount <= 8})
: Tot (y: U8.t{U8.v y == (U8.v x) `U.shift_left` (U32.v amount)}) = | false | null | false | let y = if amount = 8ul then 0uy else x `U8.shift_left` amount in
y | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt8.t",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt8.v",
"FStar.UInt.shift_left",
"Prims.op_Equality",
"FStar.UInt32.__uint_to_t",
"FStar.UInt8.__uint_to_t",
"Prims.bool",
"FStar.UInt8.shift_left",
"F... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val u8_shift_left (x: U8.t) (amount: U32.t{U32.v amount <= 8})
: Tot (y: U8.t{U8.v y == (U8.v x) `U.shift_left` (U32.v amount)}) | [] | LowParse.BitFields.u8_shift_left | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt8.t -> amount: FStar.UInt32.t{FStar.UInt32.v amount <= 8}
-> y:
FStar.UInt8.t
{FStar.UInt8.v y == FStar.UInt.shift_left (FStar.UInt8.v x) (FStar.UInt32.v amount)} | {
"end_col": 3,
"end_line": 1174,
"start_col": 1,
"start_line": 1171
} |
FStar.Pervasives.Lemma | val bitfield_mask_eq (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma
(0 <= pow2 (hi - lo) - 1 /\ pow2 (hi - lo) - 1 < pow2 tot /\
bitfield_mask tot lo hi == U.shift_left #tot (pow2 (hi - lo) - 1) lo) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let bitfield_mask_eq (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Lemma
(
0 <= pow2 (hi - lo) - 1 /\
pow2 (hi - lo) - 1 < pow2 tot /\
bitfield_mask tot lo hi == U.shift_left #tot (pow2 (hi - lo) - 1) lo
)
=
M.pow2_le_compat tot (hi - lo);
U.shift_left_value_lemma #tot (pow2 (hi - lo) -... | val bitfield_mask_eq (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma
(0 <= pow2 (hi - lo) - 1 /\ pow2 (hi - lo) - 1 < pow2 tot /\
bitfield_mask tot lo hi == U.shift_left #tot (pow2 (hi - lo) - 1) lo)
let bitfield_mask_eq (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma
(... | false | null | true | M.pow2_le_compat tot (hi - lo);
U.shift_left_value_lemma #tot (pow2 (hi - lo) - 1) lo;
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo;
M.lemma_mult_nat (pow2 (hi - lo) - 1) (pow2 lo);
M.lemma_mult_lt' (pow2 lo) (pow2 (hi - lo) - 1) (pow2 (hi - lo));
M.swap_mul (pow2 (hi - lo)) (pow2 lo);
M.swap_mul (pow2 (hi - lo) -... | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Math.Lemmas.modulo_lemma",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.unit",
"FStar.Math.Lemmas.swap_mul",
"LowParse.Math.lemma_mult_lt'",
"LowParse.Math.lemma_mult_nat",
"FStar.... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bitfield_mask_eq (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma
(0 <= pow2 (hi - lo) - 1 /\ pow2 (hi - lo) - 1 < pow2 tot /\
bitfield_mask tot lo hi == U.shift_left #tot (pow2 (hi - lo) - 1) lo) | [] | LowParse.BitFields.bitfield_mask_eq | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | tot: Prims.pos -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot}
-> FStar.Pervasives.Lemma
(ensures
0 <= Prims.pow2 (hi - lo) - 1 /\ Prims.pow2 (hi - lo) - 1 < Prims.pow2 tot /\
LowParse.BitFields.bitfield_mask tot lo hi ==
FStar.UInt.shift_left (Prims.pow2 (hi - lo) - 1) lo) | {
"end_col": 60,
"end_line": 30,
"start_col": 2,
"start_line": 22
} |
Prims.Tot | val get_bitfield_gen64 (x: U64.t) (lo: U32.t) (hi: U32.t{U32.v lo < U32.v hi /\ U32.v hi <= 64})
: Tot (y: U64.t{U64.v y == get_bitfield (U64.v x) (U32.v lo) (U32.v hi)}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let get_bitfield_gen64
(x: U64.t) (lo: U32.t) (hi: U32.t {U32.v lo < U32.v hi /\ U32.v hi <= 64})
: Tot (y: U64.t { U64.v y == get_bitfield (U64.v x) (U32.v lo) (U32.v hi) })
= get_bitfield_eq_2 #64 (U64.v x) (U32.v lo) (U32.v hi);
(x `U64.shift_left` (64ul `U32.sub` hi)) `U64.shift_right` ((64ul `U32.sub` hi) `U32... | val get_bitfield_gen64 (x: U64.t) (lo: U32.t) (hi: U32.t{U32.v lo < U32.v hi /\ U32.v hi <= 64})
: Tot (y: U64.t{U64.v y == get_bitfield (U64.v x) (U32.v lo) (U32.v hi)})
let get_bitfield_gen64 (x: U64.t) (lo: U32.t) (hi: U32.t{U32.v lo < U32.v hi /\ U32.v hi <= 64})
: Tot (y: U64.t{U64.v y == get_bitfield (U64... | false | null | false | get_bitfield_eq_2 #64 (U64.v x) (U32.v lo) (U32.v hi);
(x `U64.shift_left` (64ul `U32.sub` hi)) `U64.shift_right` ((64ul `U32.sub` hi) `U32.add` lo) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt64.t",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt32.v",
"Prims.op_LessThanOrEqual",
"FStar.UInt64.shift_right",
"FStar.UInt64.shift_left",
"FStar.UInt32.sub",
"FStar.UInt32.__uint_to_t",
"FStar.UInt32.add",
"Prims.unit",
"LowParse.BitFields.ge... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_gen64 (x: U64.t) (lo: U32.t) (hi: U32.t{U32.v lo < U32.v hi /\ U32.v hi <= 64})
: Tot (y: U64.t{U64.v y == get_bitfield (U64.v x) (U32.v lo) (U32.v hi)}) | [] | LowParse.BitFields.get_bitfield_gen64 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt64.t ->
lo: FStar.UInt32.t ->
hi: FStar.UInt32.t{FStar.UInt32.v lo < FStar.UInt32.v hi /\ FStar.UInt32.v hi <= 64}
-> y:
FStar.UInt64.t
{ FStar.UInt64.v y ==
LowParse.BitFields.get_bitfield (FStar.UInt64.v x) (FStar.UInt32.v lo) (FStar.UInt32.v hi) } | {
"end_col": 95,
"end_line": 948,
"start_col": 2,
"start_line": 947
} |
Prims.Tot | val get_bitfield_gen8 (x: U8.t) (lo: U32.t) (hi: U32.t{U32.v lo < U32.v hi /\ U32.v hi <= 8})
: Tot (y: U8.t{U8.v y == get_bitfield (U8.v x) (U32.v lo) (U32.v hi)}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let get_bitfield_gen8
(x: U8.t) (lo: U32.t) (hi: U32.t {U32.v lo < U32.v hi /\ U32.v hi <= 8})
: Tot (y: U8.t { U8.v y == get_bitfield (U8.v x) (U32.v lo) (U32.v hi) })
= get_bitfield_eq_2 #8 (U8.v x) (U32.v lo) (U32.v hi);
(* NOTE: due to https://github.com/FStarLang/karamel/issues/102 I need to introduce explicit... | val get_bitfield_gen8 (x: U8.t) (lo: U32.t) (hi: U32.t{U32.v lo < U32.v hi /\ U32.v hi <= 8})
: Tot (y: U8.t{U8.v y == get_bitfield (U8.v x) (U32.v lo) (U32.v hi)})
let get_bitfield_gen8 (x: U8.t) (lo: U32.t) (hi: U32.t{U32.v lo < U32.v hi /\ U32.v hi <= 8})
: Tot (y: U8.t{U8.v y == get_bitfield (U8.v x) (U32.v... | false | null | false | get_bitfield_eq_2 #8 (U8.v x) (U32.v lo) (U32.v hi);
let op1 = x `U8.shift_left` (8ul `U32.sub` hi) in
let op2 = op1 `U8.shift_right` ((8ul `U32.sub` hi) `U32.add` lo) in
op2 | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt8.t",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt32.v",
"Prims.op_LessThanOrEqual",
"FStar.UInt8.shift_right",
"FStar.UInt32.add",
"FStar.UInt32.sub",
"FStar.UInt32.__uint_to_t",
"FStar.UInt8.shift_left",
"Prims.unit",
"LowParse.BitFields.get_b... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_gen8 (x: U8.t) (lo: U32.t) (hi: U32.t{U32.v lo < U32.v hi /\ U32.v hi <= 8})
: Tot (y: U8.t{U8.v y == get_bitfield (U8.v x) (U32.v lo) (U32.v hi)}) | [] | LowParse.BitFields.get_bitfield_gen8 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt8.t ->
lo: FStar.UInt32.t ->
hi: FStar.UInt32.t{FStar.UInt32.v lo < FStar.UInt32.v hi /\ FStar.UInt32.v hi <= 8}
-> y:
FStar.UInt8.t
{ FStar.UInt8.v y ==
LowParse.BitFields.get_bitfield (FStar.UInt8.v x) (FStar.UInt32.v lo) (FStar.UInt32.v hi) } | {
"end_col": 5,
"end_line": 1137,
"start_col": 2,
"start_line": 1133
} |
FStar.Pervasives.Lemma | val set_bitfield_set_bitfield_get_bitfield
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot })
(lo' : nat) (hi' : nat { lo' <= hi' /\ hi' <= hi - lo }) (v' : ubitfield tot (hi' - lo'))
: Lemma
( let v = set_bitfield (get_bitfield x lo hi) lo' hi' v' in
v < pow2 (hi - lo) /\
set_b... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let set_bitfield_set_bitfield_get_bitfield
#tot x lo hi lo' hi' v'
= set_bitfield_bound (get_bitfield x lo hi) (hi - lo) lo' hi' v' ;
let x1 = set_bitfield x lo hi (set_bitfield (get_bitfield x lo hi) lo' hi' v') in
let x2 = set_bitfield x (lo + lo') (lo + hi') v' in
eq_nth x1 x2 (fun i ->
nth_set_bitfield ... | val set_bitfield_set_bitfield_get_bitfield
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot })
(lo' : nat) (hi' : nat { lo' <= hi' /\ hi' <= hi - lo }) (v' : ubitfield tot (hi' - lo'))
: Lemma
( let v = set_bitfield (get_bitfield x lo hi) lo' hi' v' in
v < pow2 (hi - lo) /\
set_b... | false | null | true | set_bitfield_bound (get_bitfield x lo hi) (hi - lo) lo' hi' v';
let x1 = set_bitfield x lo hi (set_bitfield (get_bitfield x lo hi) lo' hi' v') in
let x2 = set_bitfield x (lo + lo') (lo + hi') v' in
eq_nth x1
x2
(fun i ->
nth_set_bitfield x lo hi (set_bitfield (get_bitfield x lo hi) lo' hi' v') i;
nth_se... | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"LowParse.BitFields.ubitfield",
"LowParse.BitFields.eq_nth",
"Prims.op_LessThan",
"Prims.op_AmpAmp",
"Prims.bool",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val set_bitfield_set_bitfield_get_bitfield
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot })
(lo' : nat) (hi' : nat { lo' <= hi' /\ hi' <= hi - lo }) (v' : ubitfield tot (hi' - lo'))
: Lemma
( let v = set_bitfield (get_bitfield x lo hi) lo' hi' v' in
v < pow2 (hi - lo) /\
set_b... | [] | LowParse.BitFields.set_bitfield_set_bitfield_get_bitfield | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt.uint_t tot ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot} ->
lo': Prims.nat ->
hi': Prims.nat{lo' <= hi' /\ hi' <= hi - lo} ->
v': LowParse.BitFields.ubitfield tot (hi' - lo')
-> FStar.Pervasives.Lemma
(ensures
(let v =
LowParse.BitFields.set_bitfie... | {
"end_col": 3,
"end_line": 797,
"start_col": 2,
"start_line": 776
} |
Prims.Tot | val set_bitfield_gen8
(x: U8.t)
(lo: U32.t)
(hi: U32.t{U32.v lo < U32.v hi /\ U32.v hi <= 8})
(v: U8.t{U8.v v < pow2 (U32.v hi - U32.v lo)})
: Tot (y: U8.t{U8.v y == set_bitfield (U8.v x) (U32.v lo) (U32.v hi) (U8.v v)}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let set_bitfield_gen8
(x: U8.t) (lo: U32.t) (hi: U32.t {U32.v lo < U32.v hi /\ U32.v hi <= 8})
(v: U8.t { U8.v v < pow2 (U32.v hi - U32.v lo) })
: Tot (y: U8.t { U8.v y == set_bitfield (U8.v x) (U32.v lo) (U32.v hi) (U8.v v) })
= bitfield_mask_eq_2 8 (U32.v lo) (U32.v hi);
(* NOTE: due to https://github.com/FStar... | val set_bitfield_gen8
(x: U8.t)
(lo: U32.t)
(hi: U32.t{U32.v lo < U32.v hi /\ U32.v hi <= 8})
(v: U8.t{U8.v v < pow2 (U32.v hi - U32.v lo)})
: Tot (y: U8.t{U8.v y == set_bitfield (U8.v x) (U32.v lo) (U32.v hi) (U8.v v)})
let set_bitfield_gen8
(x: U8.t)
(lo: U32.t)
(hi: U32.... | false | null | false | bitfield_mask_eq_2 8 (U32.v lo) (U32.v hi);
let op0 = (U8.lognot 0uy) in
let op1 = op0 `U8.shift_right` (8ul `U32.sub` (hi `U32.sub` lo)) in
let op2 = op1 `U8.shift_left` lo in
let op3 = U8.lognot op2 in
let op4 = x `U8.logand` op3 in
let op5 = v `U8.shift_left` lo in
let op6 = op4 `U8.logor` op5 in
op6 | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt8.t",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt32.v",
"Prims.op_LessThanOrEqual",
"FStar.UInt8.v",
"Prims.pow2",
"Prims.op_Subtraction",
"FStar.UInt8.logor",
"FStar.UInt8.shift_left",
"FStar.UInt8.logand",
"FStar.UInt8.lognot",
"FStar.UInt8... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val set_bitfield_gen8
(x: U8.t)
(lo: U32.t)
(hi: U32.t{U32.v lo < U32.v hi /\ U32.v hi <= 8})
(v: U8.t{U8.v v < pow2 (U32.v hi - U32.v lo)})
: Tot (y: U8.t{U8.v y == set_bitfield (U8.v x) (U32.v lo) (U32.v hi) (U8.v v)}) | [] | LowParse.BitFields.set_bitfield_gen8 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt8.t ->
lo: FStar.UInt32.t ->
hi: FStar.UInt32.t{FStar.UInt32.v lo < FStar.UInt32.v hi /\ FStar.UInt32.v hi <= 8} ->
v: FStar.UInt8.t{FStar.UInt8.v v < Prims.pow2 (FStar.UInt32.v hi - FStar.UInt32.v lo)}
-> y:
FStar.UInt8.t
{ FStar.UInt8.v y ==
LowParse.BitFields.set_bit... | {
"end_col": 5,
"end_line": 1153,
"start_col": 2,
"start_line": 1144
} |
Prims.Tot | val get_bitfield16 (x: U16.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 16})
: Tot (y: U16.t{U16.v y == get_bitfield (U16.v x) lo hi}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let get_bitfield16
(x: U16.t) (lo: nat) (hi: nat {lo <= hi /\ hi <= 16})
: Tot (y: U16.t { U16.v y == get_bitfield (U16.v x) lo hi })
= (x `U16.logand` bitfield_mask16 lo hi) `u16_shift_right` (U32.uint_to_t lo) | val get_bitfield16 (x: U16.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 16})
: Tot (y: U16.t{U16.v y == get_bitfield (U16.v x) lo hi})
let get_bitfield16 (x: U16.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 16})
: Tot (y: U16.t{U16.v y == get_bitfield (U16.v x) lo hi}) = | false | null | false | (x `U16.logand` (bitfield_mask16 lo hi)) `u16_shift_right` (U32.uint_to_t lo) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt16.t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.u16_shift_right",
"FStar.UInt16.logand",
"LowParse.BitFields.bitfield_mask16",
"FStar.UInt32.uint_to_t",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt16.n",
"FStar.UInt16.v",
"LowPars... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield16 (x: U16.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 16})
: Tot (y: U16.t{U16.v y == get_bitfield (U16.v x) lo hi}) | [] | LowParse.BitFields.get_bitfield16 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt16.t -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= 16}
-> y: FStar.UInt16.t{FStar.UInt16.v y == LowParse.BitFields.get_bitfield (FStar.UInt16.v x) lo hi} | {
"end_col": 77,
"end_line": 1057,
"start_col": 2,
"start_line": 1057
} |
FStar.Pervasives.Lemma | val nth_bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot}) (i: nat{i < tot})
: Lemma (nth (bitfield_mask tot lo hi) i == (lo <= i && i < hi)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let nth_bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (i: nat {i < tot}) : Lemma
(nth (bitfield_mask tot lo hi) i == (lo <= i && i < hi))
= bitfield_mask_eq tot lo hi;
nth_shift_left #tot (pow2 (hi - lo) - 1) lo i;
if i < lo
then ()
else begin
nth_pow2_minus_one #tot (... | val nth_bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot}) (i: nat{i < tot})
: Lemma (nth (bitfield_mask tot lo hi) i == (lo <= i && i < hi))
let nth_bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot}) (i: nat{i < tot})
: Lemma (nth (bitfield_mask tot lo hi) i == (lo <= i && i <... | false | null | true | bitfield_mask_eq tot lo hi;
nth_shift_left #tot (pow2 (hi - lo) - 1) lo i;
if i < lo then () else nth_pow2_minus_one #tot (hi - lo) (i - lo) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.bool",
"LowParse.BitFields.nth_pow2_minus_one",
"Prims.op_Subtraction",
"Prims.unit",
"LowParse.BitFields.nth_shift_left",
"Prims.pow2",
"LowParse.BitFields.bitfield_mask_eq",
"Pri... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val nth_bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot}) (i: nat{i < tot})
: Lemma (nth (bitfield_mask tot lo hi) i == (lo <= i && i < hi)) | [] | LowParse.BitFields.nth_bitfield_mask | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | tot: Prims.pos -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot} -> i: Prims.nat{i < tot}
-> FStar.Pervasives.Lemma
(ensures
LowParse.BitFields.nth (LowParse.BitFields.bitfield_mask tot lo hi) i == (lo <= i && i < hi)) | {
"end_col": 7,
"end_line": 106,
"start_col": 4,
"start_line": 100
} |
Prims.Tot | val get_bitfield_raw (#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Tot (U.uint_t tot) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield_raw (#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot}) : Tot (U.uint_t tot) =
(x `U.logand` bitfield_mask tot lo hi) `U.shift_right` lo | val get_bitfield_raw (#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Tot (U.uint_t tot)
let get_bitfield_raw (#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Tot (U.uint_t tot) = | false | null | false | (x `U.logand` (bitfield_mask tot lo hi)) `U.shift_right` lo | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt.shift_right",
"FStar.UInt.logand",
"LowParse.BitFields.bitfield_mask"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_raw (#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Tot (U.uint_t tot) | [] | LowParse.BitFields.get_bitfield_raw | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt.uint_t tot -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot}
-> FStar.UInt.uint_t tot | {
"end_col": 59,
"end_line": 109,
"start_col": 2,
"start_line": 109
} |
FStar.Pervasives.Lemma | val eq_nth (#n: pos) (a b: U.uint_t n) (f: (i: nat{i < n} -> Lemma (nth a i == nth b i)))
: Lemma (a == b) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let eq_nth
(#n: pos)
(a: U.uint_t n)
(b: U.uint_t n)
(f: (
(i: nat { i < n }) ->
Lemma
(nth a i == nth b i)
))
: Lemma
(a == b)
= let g
(i: nat { i < n })
: Lemma
(U.nth a i == U.nth b i)
= f (n - 1 - i)
in
Classical.forall_intro g;
U.nth_lemma a b | val eq_nth (#n: pos) (a b: U.uint_t n) (f: (i: nat{i < n} -> Lemma (nth a i == nth b i)))
: Lemma (a == b)
let eq_nth (#n: pos) (a b: U.uint_t n) (f: (i: nat{i < n} -> Lemma (nth a i == nth b i)))
: Lemma (a == b) = | false | null | true | let g (i: nat{i < n}) : Lemma (U.nth a i == U.nth b i) = f (n - 1 - i) in
Classical.forall_intro g;
U.nth_lemma a b | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.bool",
"LowParse.BitFields.nth",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.UInt.nth_lemma",
"FStar.Classical.forall_intro",
"FStar.UI... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val eq_nth (#n: pos) (a b: U.uint_t n) (f: (i: nat{i < n} -> Lemma (nth a i == nth b i)))
: Lemma (a == b) | [] | LowParse.BitFields.eq_nth | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
a: FStar.UInt.uint_t n ->
b: FStar.UInt.uint_t n ->
f:
(i: Prims.nat{i < n}
-> FStar.Pervasives.Lemma
(ensures LowParse.BitFields.nth a i == LowParse.BitFields.nth b i))
-> FStar.Pervasives.Lemma (ensures a == b) | {
"end_col": 17,
"end_line": 69,
"start_col": 1,
"start_line": 62
} |
FStar.Pervasives.Lemma | val nth_le_pow2_m (#n: pos) (a: U.uint_t n) (m: nat{m <= n}) (i: nat{i < n})
: Lemma (requires (a < pow2 m /\ m <= i)) (ensures (nth a i == false)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let nth_le_pow2_m
(#n: pos)
(a: U.uint_t n)
(m: nat {m <= n})
(i: nat {i < n})
: Lemma
(requires (a < pow2 m /\ m <= i))
(ensures (nth a i == false))
= logand_mask a m;
M.modulo_lemma a (pow2 m);
nth_pow2_minus_one #n m i;
nth_logand a (pow2 m - 1) i | val nth_le_pow2_m (#n: pos) (a: U.uint_t n) (m: nat{m <= n}) (i: nat{i < n})
: Lemma (requires (a < pow2 m /\ m <= i)) (ensures (nth a i == false))
let nth_le_pow2_m (#n: pos) (a: U.uint_t n) (m: nat{m <= n}) (i: nat{i < n})
: Lemma (requires (a < pow2 m /\ m <= i)) (ensures (nth a i == false)) = | false | null | true | logand_mask a m;
M.modulo_lemma a (pow2 m);
nth_pow2_minus_one #n m i;
nth_logand a (pow2 m - 1) i | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.BitFields.nth_logand",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.unit",
"LowParse.BitFields.nth_pow2_minus_one",
"FStar.Math.Lemmas.modulo_lemma",
"LowParse.BitFields.log... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val nth_le_pow2_m (#n: pos) (a: U.uint_t n) (m: nat{m <= n}) (i: nat{i < n})
: Lemma (requires (a < pow2 m /\ m <= i)) (ensures (nth a i == false)) | [] | LowParse.BitFields.nth_le_pow2_m | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | a: FStar.UInt.uint_t n -> m: Prims.nat{m <= n} -> i: Prims.nat{i < n}
-> FStar.Pervasives.Lemma (requires a < Prims.pow2 m /\ m <= i)
(ensures LowParse.BitFields.nth a i == false) | {
"end_col": 29,
"end_line": 192,
"start_col": 2,
"start_line": 189
} |
FStar.Pervasives.Lemma | val nth_get_bitfield_raw
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(i: nat{i < tot})
: Lemma (nth (get_bitfield_raw x lo hi) i == (i < hi - lo && nth x (i + lo))) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let nth_get_bitfield_raw (#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot}) (i: nat {i < tot}) : Lemma
(nth (get_bitfield_raw x lo hi) i == (i < hi - lo && nth x (i + lo)))
= nth_shift_right (x `U.logand` bitfield_mask tot lo hi) lo i;
if i + lo < tot
then begin
nth_logand x (bitfield_m... | val nth_get_bitfield_raw
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(i: nat{i < tot})
: Lemma (nth (get_bitfield_raw x lo hi) i == (i < hi - lo && nth x (i + lo)))
let nth_get_bitfield_raw
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi... | false | null | true | nth_shift_right (x `U.logand` (bitfield_mask tot lo hi)) lo i;
if i + lo < tot
then
(nth_logand x (bitfield_mask tot lo hi) (i + lo);
nth_bitfield_mask tot lo hi (i + lo)) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Addition",
"LowParse.BitFields.nth_bitfield_mask",
"Prims.unit",
"LowParse.BitFields.nth_logand",
"LowParse.BitFields.bitfield_mask",
"Prims.bool",
"LowPars... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val nth_get_bitfield_raw
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(i: nat{i < tot})
: Lemma (nth (get_bitfield_raw x lo hi) i == (i < hi - lo && nth x (i + lo))) | [] | LowParse.BitFields.nth_get_bitfield_raw | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt.uint_t tot ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot} ->
i: Prims.nat{i < tot}
-> FStar.Pervasives.Lemma
(ensures
LowParse.BitFields.nth (LowParse.BitFields.get_bitfield_raw x lo hi) i ==
(i < hi - lo && LowParse.BitFields.nth x (i + lo))) | {
"end_col": 6,
"end_line": 143,
"start_col": 2,
"start_line": 137
} |
FStar.Pervasives.Lemma | val bitfield_mask_eq_2 (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma
(bitfield_mask tot lo hi ==
U.shift_left #tot ((U.lognot 0) `U.shift_right` (tot - (hi - lo))) lo) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let bitfield_mask_eq_2 (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Lemma
(
bitfield_mask tot lo hi == U.shift_left #tot (U.lognot 0 `U.shift_right` (tot - (hi - lo))) lo
)
= bitfield_mask_eq tot lo hi;
pow2_m_minus_one_eq tot (tot - (hi - lo));
U.lemma_lognot_value_mod #tot 0;
U.shift_right... | val bitfield_mask_eq_2 (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma
(bitfield_mask tot lo hi ==
U.shift_left #tot ((U.lognot 0) `U.shift_right` (tot - (hi - lo))) lo)
let bitfield_mask_eq_2 (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma
(bitfield_mask tot lo hi ==
... | false | null | true | bitfield_mask_eq tot lo hi;
pow2_m_minus_one_eq tot (tot - (hi - lo));
U.lemma_lognot_value_mod #tot 0;
U.shift_right_value_lemma #tot (pow2 tot - 1) (tot - (hi - lo)) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt.shift_right_value_lemma",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.unit",
"FStar.UInt.lemma_lognot_value_mod",
"LowParse.BitFields.pow2_m_minus_one_eq",
"LowParse.BitFields.bitfield_mask_eq",
"P... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bitfield_mask_eq_2 (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma
(bitfield_mask tot lo hi ==
U.shift_left #tot ((U.lognot 0) `U.shift_right` (tot - (hi - lo))) lo) | [] | LowParse.BitFields.bitfield_mask_eq_2 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | tot: Prims.pos -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot}
-> FStar.Pervasives.Lemma
(ensures
LowParse.BitFields.bitfield_mask tot lo hi ==
FStar.UInt.shift_left (FStar.UInt.shift_right (FStar.UInt.lognot 0) (tot - (hi - lo))) lo) | {
"end_col": 65,
"end_line": 866,
"start_col": 2,
"start_line": 863
} |
Prims.Tot | val get_bitfield
(#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Tot (ubitfield tot (hi - lo)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield
(#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Tot (ubitfield tot (hi - lo))
= get_bitfield_raw_bounded x lo hi;
get_bitfield_raw x lo hi | val get_bitfield
(#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Tot (ubitfield tot (hi - lo))
let get_bitfield (#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Tot (ubitfield tot (hi - lo)) = | false | null | false | get_bitfield_raw_bounded x lo hi;
get_bitfield_raw x lo hi | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.get_bitfield_raw",
"Prims.unit",
"LowParse.BitFields.get_bitfield_raw_bounded",
"LowParse.BitFields.ubitfield",
"Prims.op_Subtraction"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield
(#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Tot (ubitfield tot (hi - lo)) | [] | LowParse.BitFields.get_bitfield | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt.uint_t tot -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot}
-> LowParse.BitFields.ubitfield tot (hi - lo) | {
"end_col": 26,
"end_line": 206,
"start_col": 2,
"start_line": 205
} |
FStar.Pervasives.Lemma | val nth_not_bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot}) (i: nat{i < tot})
: Lemma (nth (not_bitfield_mask tot lo hi) i == (i < lo || hi <= i)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let nth_not_bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (i: nat {i < tot}) : Lemma
(nth (not_bitfield_mask tot lo hi) i == (i < lo || hi <= i))
= nth_lognot (bitfield_mask tot lo hi) i;
nth_bitfield_mask tot lo hi i | val nth_not_bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot}) (i: nat{i < tot})
: Lemma (nth (not_bitfield_mask tot lo hi) i == (i < lo || hi <= i))
let nth_not_bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot}) (i: nat{i < tot})
: Lemma (nth (not_bitfield_mask tot lo hi) i ==... | false | null | true | nth_lognot (bitfield_mask tot lo hi) i;
nth_bitfield_mask tot lo hi i | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.BitFields.nth_bitfield_mask",
"Prims.unit",
"LowParse.BitFields.nth_lognot",
"LowParse.BitFields.bitfield_mask",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.bool",
"Lo... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val nth_not_bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot}) (i: nat{i < tot})
: Lemma (nth (not_bitfield_mask tot lo hi) i == (i < lo || hi <= i)) | [] | LowParse.BitFields.nth_not_bitfield_mask | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | tot: Prims.pos -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot} -> i: Prims.nat{i < tot}
-> FStar.Pervasives.Lemma
(ensures
LowParse.BitFields.nth (LowParse.BitFields.not_bitfield_mask tot lo hi) i ==
(i < lo || hi <= i)) | {
"end_col": 31,
"end_line": 295,
"start_col": 2,
"start_line": 294
} |
FStar.Pervasives.Lemma | val nth_get_bitfield
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(i: nat{i < tot})
: Lemma (nth (get_bitfield x lo hi) i == (i < hi - lo && nth x (i + lo))) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let nth_get_bitfield (#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot}) (i: nat {i < tot}) : Lemma
(nth (get_bitfield x lo hi) i == (i < hi - lo && nth x (i + lo)))
= nth_get_bitfield_raw x lo hi i | val nth_get_bitfield
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(i: nat{i < tot})
: Lemma (nth (get_bitfield x lo hi) i == (i < hi - lo && nth x (i + lo)))
let nth_get_bitfield
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= ... | false | null | true | nth_get_bitfield_raw x lo hi i | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"LowParse.BitFields.nth_get_bitfield_raw",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.bool",
"LowParse.BitFields.nth",
"LowParse.BitFields.ge... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val nth_get_bitfield
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(i: nat{i < tot})
: Lemma (nth (get_bitfield x lo hi) i == (i < hi - lo && nth x (i + lo))) | [] | LowParse.BitFields.nth_get_bitfield | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt.uint_t tot ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot} ->
i: Prims.nat{i < tot}
-> FStar.Pervasives.Lemma
(ensures
LowParse.BitFields.nth (LowParse.BitFields.get_bitfield x lo hi) i ==
(i < hi - lo && LowParse.BitFields.nth x (i + lo))) | {
"end_col": 32,
"end_line": 210,
"start_col": 2,
"start_line": 210
} |
FStar.Pervasives.Lemma | val bitfield_mask_mod_pow2_lo
(tot: pos)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(m: nat{m <= lo})
: Lemma (bitfield_mask tot lo hi % pow2 m == 0) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let bitfield_mask_mod_pow2_lo
(tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (m: nat {m <= lo})
: Lemma
(bitfield_mask tot lo hi % pow2 m == 0)
= M.pow2_multiplication_modulo_lemma_1 (pow2 (hi - lo) - 1) m lo | val bitfield_mask_mod_pow2_lo
(tot: pos)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(m: nat{m <= lo})
: Lemma (bitfield_mask tot lo hi % pow2 m == 0)
let bitfield_mask_mod_pow2_lo
(tot: pos)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(m: nat{m <= lo})
: Lemma (bit... | false | null | true | M.pow2_multiplication_modulo_lemma_1 (pow2 (hi - lo) - 1) m lo | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"LowParse.BitFields.... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bitfield_mask_mod_pow2_lo
(tot: pos)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(m: nat{m <= lo})
: Lemma (bitfield_mask tot lo hi % pow2 m == 0) | [] | LowParse.BitFields.bitfield_mask_mod_pow2_lo | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | tot: Prims.pos -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot} -> m: Prims.nat{m <= lo}
-> FStar.Pervasives.Lemma (ensures LowParse.BitFields.bitfield_mask tot lo hi % Prims.pow2 m == 0) | {
"end_col": 64,
"end_line": 262,
"start_col": 2,
"start_line": 262
} |
Prims.Tot | val bitfield_eq32_lhs (x: U32.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 32}) : Tot U32.t | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let bitfield_eq32_lhs
(x: U32.t) (lo: nat) (hi: nat {lo <= hi /\ hi <= 32})
: Tot U32.t
= x `U32.logand` bitfield_mask32 lo hi | val bitfield_eq32_lhs (x: U32.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 32}) : Tot U32.t
let bitfield_eq32_lhs (x: U32.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 32}) : Tot U32.t = | false | null | false | x `U32.logand` (bitfield_mask32 lo hi) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt32.t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.logand",
"LowParse.BitFields.bitfield_mask32"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bitfield_eq32_lhs (x: U32.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 32}) : Tot U32.t | [] | LowParse.BitFields.bitfield_eq32_lhs | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt32.t -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= 32} -> FStar.UInt32.t | {
"end_col": 38,
"end_line": 1004,
"start_col": 2,
"start_line": 1004
} |
FStar.Pervasives.Lemma | val get_bitfield_raw_bounded
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
: Lemma (get_bitfield_raw x lo hi < pow2 (hi - lo)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield_raw_bounded
(#tot: pos) (x: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Lemma
(get_bitfield_raw x lo hi < pow2 (hi - lo))
= get_bitfield_raw_eq_logand_pow2_hi_lo_minus_one x lo hi;
logand_mask (get_bitfield_raw x lo hi) (hi - lo);
M.lemma_mod_lt x (pow2 (hi - lo)) | val get_bitfield_raw_bounded
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
: Lemma (get_bitfield_raw x lo hi < pow2 (hi - lo))
let get_bitfield_raw_bounded
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
: Lemma ... | false | null | true | get_bitfield_raw_eq_logand_pow2_hi_lo_minus_one x lo hi;
logand_mask (get_bitfield_raw x lo hi) (hi - lo);
M.lemma_mod_lt x (pow2 (hi - lo)) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Math.Lemmas.lemma_mod_lt",
"Prims.pow2",
"Prims.op_Subtraction",
"Prims.unit",
"LowParse.BitFields.logand_mask",
"LowParse.BitFields.get_bitfield_raw",
"LowParse.BitFields.get_bitfie... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_raw_bounded
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
: Lemma (get_bitfield_raw x lo hi < pow2 (hi - lo)) | [] | LowParse.BitFields.get_bitfield_raw_bounded | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt.uint_t tot -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot}
-> FStar.Pervasives.Lemma
(ensures LowParse.BitFields.get_bitfield_raw x lo hi < Prims.pow2 (hi - lo)) | {
"end_col": 35,
"end_line": 200,
"start_col": 2,
"start_line": 198
} |
FStar.Pervasives.Lemma | val nth_zero (tot: pos) (i: nat{i < tot}) : Lemma (nth #tot 0 i == false) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let nth_zero
(tot: pos)
(i: nat {i < tot})
: Lemma
(nth #tot 0 i == false)
= U.zero_nth_lemma #tot i | val nth_zero (tot: pos) (i: nat{i < tot}) : Lemma (nth #tot 0 i == false)
let nth_zero (tot: pos) (i: nat{i < tot}) : Lemma (nth #tot 0 i == false) = | false | null | true | U.zero_nth_lemma #tot i | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt.zero_nth_lemma",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.bool",
"LowParse.BitFields.nth",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val nth_zero (tot: pos) (i: nat{i < tot}) : Lemma (nth #tot 0 i == false) | [] | LowParse.BitFields.nth_zero | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | tot: Prims.pos -> i: Prims.nat{i < tot}
-> FStar.Pervasives.Lemma (ensures LowParse.BitFields.nth 0 i == false) | {
"end_col": 25,
"end_line": 410,
"start_col": 2,
"start_line": 410
} |
Prims.Tot | val set_bitfield64
(x: U64.t)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= 64})
(v: U64.t{U64.v v < pow2 (hi - lo)})
: Tot (y: U64.t{U64.v y == set_bitfield (U64.v x) lo hi (U64.v v)}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let set_bitfield64
(x: U64.t) (lo: nat) (hi: nat {lo <= hi /\ hi <= 64})
(v: U64.t { U64.v v < pow2 (hi - lo) })
: Tot (y: U64.t { U64.v y == set_bitfield (U64.v x) lo hi (U64.v v) })
= (x `U64.logand` not_bitfield_mask64 lo hi) `U64.logor` (v `u64_shift_left` U32.uint_to_t lo) | val set_bitfield64
(x: U64.t)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= 64})
(v: U64.t{U64.v v < pow2 (hi - lo)})
: Tot (y: U64.t{U64.v y == set_bitfield (U64.v x) lo hi (U64.v v)})
let set_bitfield64
(x: U64.t)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= 64})
(v: U64.t{U64.v v <... | false | null | false | (x `U64.logand` (not_bitfield_mask64 lo hi)) `U64.logor` (v `u64_shift_left` (U32.uint_to_t lo)) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt64.t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.UInt64.v",
"Prims.pow2",
"Prims.op_Subtraction",
"FStar.UInt64.logor",
"FStar.UInt64.logand",
"LowParse.BitFields.not_bitfield_mask64",
"LowParse.BitFields.u64_shift_left",
"F... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val set_bitfield64
(x: U64.t)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= 64})
(v: U64.t{U64.v v < pow2 (hi - lo)})
: Tot (y: U64.t{U64.v y == set_bitfield (U64.v x) lo hi (U64.v v)}) | [] | LowParse.BitFields.set_bitfield64 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt64.t ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= 64} ->
v: FStar.UInt64.t{FStar.UInt64.v v < Prims.pow2 (hi - lo)}
-> y:
FStar.UInt64.t
{ FStar.UInt64.v y ==
LowParse.BitFields.set_bitfield (FStar.UInt64.v x) lo hi (FStar.UInt64.v v) } | {
"end_col": 94,
"end_line": 921,
"start_col": 2,
"start_line": 921
} |
Prims.Tot | val set_bitfield
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
: Tot (U.uint_t tot) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let set_bitfield
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
: Tot (U.uint_t tot)
= (x `U.logand` not_bitfield_mask tot lo hi) `U.logor` (v `U.shift_left` lo) | val set_bitfield
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
: Tot (U.uint_t tot)
let set_bitfield
(#tot: pos)
(x: U.uint_t tot)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= tot})
(v: ubitfield tot (hi - lo))
: Tot (U.uint_t tot)... | false | null | false | (x `U.logand` (not_bitfield_mask tot lo hi)) `U.logor` (v `U.shift_left` lo) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.ubitfield",
"Prims.op_Subtraction",
"FStar.UInt.logor",
"FStar.UInt.logand",
"LowParse.BitFields.not_bitfield_mask",
"FStar.UInt.shift_left"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val set_bitfield
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
: Tot (U.uint_t tot) | [] | LowParse.BitFields.set_bitfield | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt.uint_t tot ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot} ->
v: LowParse.BitFields.ubitfield tot (hi - lo)
-> FStar.UInt.uint_t tot | {
"end_col": 76,
"end_line": 301,
"start_col": 2,
"start_line": 301
} |
FStar.Pervasives.Lemma | val set_bitfield_full
(#tot: pos) (x: U.uint_t tot) (y: ubitfield tot tot)
: Lemma
(set_bitfield x 0 tot y == y) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let set_bitfield_full
(#tot: pos) (x: U.uint_t tot) (y: ubitfield tot tot)
: Lemma
(set_bitfield x 0 tot y == y)
= eq_nth (set_bitfield x 0 tot y) y (fun i ->
nth_set_bitfield x 0 tot y i
) | val set_bitfield_full
(#tot: pos) (x: U.uint_t tot) (y: ubitfield tot tot)
: Lemma
(set_bitfield x 0 tot y == y)
let set_bitfield_full (#tot: pos) (x: U.uint_t tot) (y: ubitfield tot tot)
: Lemma (set_bitfield x 0 tot y == y) = | false | null | true | eq_nth (set_bitfield x 0 tot y) y (fun i -> nth_set_bitfield x 0 tot y i) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"LowParse.BitFields.ubitfield",
"LowParse.BitFields.eq_nth",
"LowParse.BitFields.set_bitfield",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"LowParse.BitFields.nth_set_bitfield",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val set_bitfield_full
(#tot: pos) (x: U.uint_t tot) (y: ubitfield tot tot)
: Lemma
(set_bitfield x 0 tot y == y) | [] | LowParse.BitFields.set_bitfield_full | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt.uint_t tot -> y: LowParse.BitFields.ubitfield tot tot
-> FStar.Pervasives.Lemma (ensures LowParse.BitFields.set_bitfield x 0 tot y == y) | {
"end_col": 3,
"end_line": 395,
"start_col": 2,
"start_line": 393
} |
FStar.Pervasives.Lemma | val get_bitfield_full
(#tot: pos)
(x: U.uint_t tot)
: Lemma
(get_bitfield x 0 tot == x) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield_full
(#tot: pos)
(x: U.uint_t tot)
: Lemma
(get_bitfield x 0 tot == x)
= eq_nth (get_bitfield x 0 tot) x (fun i ->
nth_get_bitfield x 0 tot i
) | val get_bitfield_full
(#tot: pos)
(x: U.uint_t tot)
: Lemma
(get_bitfield x 0 tot == x)
let get_bitfield_full (#tot: pos) (x: U.uint_t tot) : Lemma (get_bitfield x 0 tot == x) = | false | null | true | eq_nth (get_bitfield x 0 tot) x (fun i -> nth_get_bitfield x 0 tot i) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"LowParse.BitFields.eq_nth",
"LowParse.BitFields.get_bitfield",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"LowParse.BitFields.nth_get_bitfield",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_full
(#tot: pos)
(x: U.uint_t tot)
: Lemma
(get_bitfield x 0 tot == x) | [] | LowParse.BitFields.get_bitfield_full | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt.uint_t tot
-> FStar.Pervasives.Lemma (ensures LowParse.BitFields.get_bitfield x 0 tot == x) | {
"end_col": 3,
"end_line": 431,
"start_col": 2,
"start_line": 429
} |
FStar.Pervasives.Lemma | val get_bitfield_partition
(#tot: pos)
(x y: U.uint_t tot)
(lo: nat)
(hi: nat { lo <= hi /\ hi <= tot })
(l: list nat)
: Lemma
(requires (get_bitfield_partition_prop x y lo hi l))
(ensures (get_bitfield x lo hi == get_bitfield y lo hi)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield_partition = get_bitfield_partition' | val get_bitfield_partition
(#tot: pos)
(x y: U.uint_t tot)
(lo: nat)
(hi: nat { lo <= hi /\ hi <= tot })
(l: list nat)
: Lemma
(requires (get_bitfield_partition_prop x y lo hi l))
(ensures (get_bitfield x lo hi == get_bitfield y lo hi))
let get_bitfield_partition = | false | null | true | get_bitfield_partition' | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"LowParse.BitFields.get_bitfield_partition'"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_partition
(#tot: pos)
(x y: U.uint_t tot)
(lo: nat)
(hi: nat { lo <= hi /\ hi <= tot })
(l: list nat)
: Lemma
(requires (get_bitfield_partition_prop x y lo hi l))
(ensures (get_bitfield x lo hi == get_bitfield y lo hi)) | [] | LowParse.BitFields.get_bitfield_partition | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt.uint_t tot ->
y: FStar.UInt.uint_t tot ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot} ->
l: Prims.list Prims.nat
-> FStar.Pervasives.Lemma (requires LowParse.BitFields.get_bitfield_partition_prop x y lo hi l)
(ensures LowParse.BitFields.get_bitfield x lo hi == LowPar... | {
"end_col": 52,
"end_line": 696,
"start_col": 29,
"start_line": 696
} |
FStar.Pervasives.Lemma | val set_bitfield_set_bitfield_other
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
(lo' : nat) (hi' : nat { lo' <= hi' /\ hi' <= tot }) (v' : ubitfield tot (hi' - lo'))
: Lemma
(requires (hi' <= lo \/ hi <= lo'))
(ensures (set_bitfield (set_bitfield x ... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let set_bitfield_set_bitfield_other
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
(lo' : nat) (hi' : nat { lo' <= hi' /\ hi' <= tot }) (v' : ubitfield tot (hi' - lo'))
: Lemma
(requires (hi' <= lo \/ hi <= lo'))
(ensures (set_bitfield (set_bitfield x ... | val set_bitfield_set_bitfield_other
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
(lo' : nat) (hi' : nat { lo' <= hi' /\ hi' <= tot }) (v' : ubitfield tot (hi' - lo'))
: Lemma
(requires (hi' <= lo \/ hi <= lo'))
(ensures (set_bitfield (set_bitfield x ... | false | null | true | eq_nth (set_bitfield (set_bitfield x lo hi v) lo' hi' v')
(set_bitfield (set_bitfield x lo' hi' v') lo hi v)
(fun i ->
nth_set_bitfield (set_bitfield x lo hi v) lo' hi' v' i;
nth_set_bitfield x lo hi v i;
nth_set_bitfield (set_bitfield x lo' hi' v') lo hi v i;
nth_set_bitfield x lo' hi' v' i... | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.ubitfield",
"Prims.op_Subtraction",
"LowParse.BitFields.eq_nth",
"LowParse.BitFields.set_bitfield",
"Prims.op_LessThan",
"LowParse.BitFields.nth_set_bitfield",
"Prims.un... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val set_bitfield_set_bitfield_other
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
(lo' : nat) (hi' : nat { lo' <= hi' /\ hi' <= tot }) (v' : ubitfield tot (hi' - lo'))
: Lemma
(requires (hi' <= lo \/ hi <= lo'))
(ensures (set_bitfield (set_bitfield x ... | [] | LowParse.BitFields.set_bitfield_set_bitfield_other | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt.uint_t tot ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot} ->
v: LowParse.BitFields.ubitfield tot (hi - lo) ->
lo': Prims.nat ->
hi': Prims.nat{lo' <= hi' /\ hi' <= tot} ->
v': LowParse.BitFields.ubitfield tot (hi' - lo')
-> FStar.Pervasives.Lemma (requires hi' <= l... | {
"end_col": 3,
"end_line": 387,
"start_col": 2,
"start_line": 382
} |
FStar.Pervasives.Lemma | val set_bitfield_set_bitfield_same_gen
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
(lo' : nat) (hi' : nat { lo' <= lo /\ hi <= hi' /\ hi' <= tot })
(v' : ubitfield tot (hi' - lo'))
: Lemma
(ensures (set_bitfield (set_bitfield x lo hi v) lo' hi' v' =... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let set_bitfield_set_bitfield_same_gen
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
(lo' : nat) (hi' : nat { lo' <= lo /\ hi <= hi' /\ hi' <= tot })
(v' : ubitfield tot (hi' - lo'))
: Lemma
(ensures (set_bitfield (set_bitfield x lo hi v) lo' hi' v' =... | val set_bitfield_set_bitfield_same_gen
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
(lo' : nat) (hi' : nat { lo' <= lo /\ hi <= hi' /\ hi' <= tot })
(v' : ubitfield tot (hi' - lo'))
: Lemma
(ensures (set_bitfield (set_bitfield x lo hi v) lo' hi' v' =... | false | null | true | eq_nth (set_bitfield (set_bitfield x lo hi v) lo' hi' v')
(set_bitfield x lo' hi' v')
(fun i ->
nth_set_bitfield (set_bitfield x lo hi v) lo' hi' v' i;
nth_set_bitfield x lo hi v i;
nth_set_bitfield x lo' hi' v' i) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.ubitfield",
"Prims.op_Subtraction",
"LowParse.BitFields.eq_nth",
"LowParse.BitFields.set_bitfield",
"Prims.op_LessThan",
"LowParse.BitFields.nth_set_bitfield",
"Prims.un... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val set_bitfield_set_bitfield_same_gen
(#tot: pos) (x: U.uint_t tot)
(lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) (v: ubitfield tot (hi - lo))
(lo' : nat) (hi' : nat { lo' <= lo /\ hi <= hi' /\ hi' <= tot })
(v' : ubitfield tot (hi' - lo'))
: Lemma
(ensures (set_bitfield (set_bitfield x lo hi v) lo' hi' v' =... | [] | LowParse.BitFields.set_bitfield_set_bitfield_same_gen | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt.uint_t tot ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot} ->
v: LowParse.BitFields.ubitfield tot (hi - lo) ->
lo': Prims.nat ->
hi': Prims.nat{lo' <= lo /\ hi <= hi' /\ hi' <= tot} ->
v': LowParse.BitFields.ubitfield tot (hi' - lo')
-> FStar.Pervasives.Lemma
(e... | {
"end_col": 3,
"end_line": 373,
"start_col": 2,
"start_line": 369
} |
Prims.Tot | val not_bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Tot (x: U.uint_t tot {x == U.lognot (bitfield_mask tot lo hi)}) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let not_bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot })
: Tot (x: U.uint_t tot {x == U.lognot (bitfield_mask tot lo hi)})
= [@inline_let]
let a = bitfield_mask tot hi tot in
[@inline_let]
let b = bitfield_mask tot 0 lo in
[@inline_let]
let _ =
bitfield_mask_mod_pow2_lo tot hi tot l... | val not_bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Tot (x: U.uint_t tot {x == U.lognot (bitfield_mask tot lo hi)})
let not_bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Tot (x: U.uint_t tot {x == U.lognot (bitfield_mask tot lo hi)}) = | false | null | false | [@@ inline_let ]let a = bitfield_mask tot hi tot in
[@@ inline_let ]let b = bitfield_mask tot 0 lo in
[@@ inline_let ]let _ =
bitfield_mask_mod_pow2_lo tot hi tot lo;
bitfield_mask_lt_pow2_hi tot 0 lo;
logor_disjoint a b lo;
eq_nth (a `U.logor` b)
(U.lognot (bitfield_mask tot lo hi))
(fun i ->
n... | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"Prims.pos",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Pervasives.normalize_term",
"FStar.UInt.uint_t",
"Prims.eq2",
"FStar.UInt.lognot",
"LowParse.BitFields.bitfield_mask",
"Prims.op_Addition",
"Prims.unit",
"LowParse.BitFields.eq_nth",
"FStar.UInt.logor"... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val not_bitfield_mask (tot: pos) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Tot (x: U.uint_t tot {x == U.lognot (bitfield_mask tot lo hi)}) | [] | LowParse.BitFields.not_bitfield_mask | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | tot: Prims.pos -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= tot}
-> x: FStar.UInt.uint_t tot {x == FStar.UInt.lognot (LowParse.BitFields.bitfield_mask tot lo hi)} | {
"end_col": 24,
"end_line": 290,
"start_col": 2,
"start_line": 275
} |
Prims.Tot | val bitfield_eq16_rhs
(x: U16.t)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= 16})
(v: U16.t{U16.v v < pow2 (hi - lo)})
: Tot (y: U16.t{bitfield_eq16_lhs x lo hi == y <==> (get_bitfield16 x lo hi <: U16.t) == v}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let bitfield_eq16_rhs
(x: U16.t) (lo: nat) (hi: nat {lo <= hi /\ hi <= 16})
(v: U16.t { U16.v v < pow2 (hi - lo) })
: Tot (y: U16.t { bitfield_eq16_lhs x lo hi == y <==> (get_bitfield16 x lo hi <: U16.t) == v })
= [@inline_let] let _ =
bitfield_eq_shift (U16.v x) lo hi (U16.v v)
in
v `u16_shift_left` U32.ui... | val bitfield_eq16_rhs
(x: U16.t)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= 16})
(v: U16.t{U16.v v < pow2 (hi - lo)})
: Tot (y: U16.t{bitfield_eq16_lhs x lo hi == y <==> (get_bitfield16 x lo hi <: U16.t) == v})
let bitfield_eq16_rhs
(x: U16.t)
(lo: nat)
(hi: nat{lo <= hi /\ hi <=... | false | null | false | [@@ inline_let ]let _ = bitfield_eq_shift (U16.v x) lo hi (U16.v v) in
v `u16_shift_left` (U32.uint_to_t lo) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt16.t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.UInt16.v",
"Prims.pow2",
"Prims.op_Subtraction",
"LowParse.BitFields.u16_shift_left",
"FStar.UInt32.uint_to_t",
"Prims.unit",
"LowParse.BitFields.bitfield_eq_shift",
"FStar.UI... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bitfield_eq16_rhs
(x: U16.t)
(lo: nat)
(hi: nat{lo <= hi /\ hi <= 16})
(v: U16.t{U16.v v < pow2 (hi - lo)})
: Tot (y: U16.t{bitfield_eq16_lhs x lo hi == y <==> (get_bitfield16 x lo hi <: U16.t) == v}) | [] | LowParse.BitFields.bitfield_eq16_rhs | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt16.t ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= 16} ->
v: FStar.UInt16.t{FStar.UInt16.v v < Prims.pow2 (hi - lo)}
-> y:
FStar.UInt16.t
{ LowParse.BitFields.bitfield_eq16_lhs x lo hi == y <==>
LowParse.BitFields.get_bitfield16 x lo hi == v } | {
"end_col": 37,
"end_line": 1091,
"start_col": 2,
"start_line": 1088
} |
FStar.Pervasives.Lemma | val get_bitfield_partition_2
(#tot: pos)
(mid: nat { mid <= tot })
(x y: U.uint_t tot)
: Lemma
(requires (
get_bitfield x 0 mid == get_bitfield y 0 mid /\
get_bitfield x mid tot == get_bitfield y mid tot
))
(ensures (
x == y
)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield_partition_2
(#tot: pos)
(mid: nat { mid <= tot })
(x y: U.uint_t tot)
: Lemma
(requires (
get_bitfield x 0 mid == get_bitfield y 0 mid /\
get_bitfield x mid tot == get_bitfield y mid tot
))
(ensures (
x == y
))
= get_bitfield_partition_2_gen 0 mid tot x y;
get_bitfield_ful... | val get_bitfield_partition_2
(#tot: pos)
(mid: nat { mid <= tot })
(x y: U.uint_t tot)
: Lemma
(requires (
get_bitfield x 0 mid == get_bitfield y 0 mid /\
get_bitfield x mid tot == get_bitfield y mid tot
))
(ensures (
x == y
))
let get_bitfield_partition_2 (#tot: pos) (mid: nat{mid <= tot}) ... | false | null | true | get_bitfield_partition_2_gen 0 mid tot x y;
get_bitfield_full x;
get_bitfield_full y | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt.uint_t",
"LowParse.BitFields.get_bitfield_full",
"Prims.unit",
"LowParse.BitFields.get_bitfield_partition_2_gen",
"Prims.l_and",
"Prims.eq2",
"LowParse.BitFields.ubitfield",
"Prims.op_Subtraction",
"LowParse.BitFi... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_partition_2
(#tot: pos)
(mid: nat { mid <= tot })
(x y: U.uint_t tot)
: Lemma
(requires (
get_bitfield x 0 mid == get_bitfield y 0 mid /\
get_bitfield x mid tot == get_bitfield y mid tot
))
(ensures (
x == y
)) | [] | LowParse.BitFields.get_bitfield_partition_2 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | mid: Prims.nat{mid <= tot} -> x: FStar.UInt.uint_t tot -> y: FStar.UInt.uint_t tot
-> FStar.Pervasives.Lemma
(requires
LowParse.BitFields.get_bitfield x 0 mid == LowParse.BitFields.get_bitfield y 0 mid /\
LowParse.BitFields.get_bitfield x mid tot == LowParse.BitFields.get_bitfield y mid tot)
... | {
"end_col": 21,
"end_line": 678,
"start_col": 2,
"start_line": 676
} |
FStar.Pervasives.Lemma | val get_bitfield_logxor
(#tot: pos) (x y: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Lemma
(get_bitfield (x `U.logxor` y) lo hi == get_bitfield x lo hi `U.logxor` get_bitfield y lo hi) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield_logxor
(#tot: pos) (x y: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Lemma
(get_bitfield (x `U.logxor` y) lo hi == get_bitfield x lo hi `U.logxor` get_bitfield y lo hi)
= eq_nth (get_bitfield (x `U.logxor` y) lo hi) (get_bitfield x lo hi `U.logxor` get_bitfield y lo hi) (fun i ->
... | val get_bitfield_logxor
(#tot: pos) (x y: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Lemma
(get_bitfield (x `U.logxor` y) lo hi == get_bitfield x lo hi `U.logxor` get_bitfield y lo hi)
let get_bitfield_logxor (#tot: pos) (x y: U.uint_t tot) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma
... | false | null | true | eq_nth (get_bitfield (x `U.logxor` y) lo hi)
((get_bitfield x lo hi) `U.logxor` (get_bitfield y lo hi))
(fun i ->
nth_get_bitfield (x `U.logxor` y) lo hi i;
nth_get_bitfield x lo hi i;
nth_get_bitfield y lo hi i) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.eq_nth",
"LowParse.BitFields.get_bitfield",
"FStar.UInt.logxor",
"Prims.op_LessThan",
"LowParse.BitFields.nth_get_bitfield",
"Prims.unit",
"Prims.l_True",
"Prims.squas... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_logxor
(#tot: pos) (x y: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Lemma
(get_bitfield (x `U.logxor` y) lo hi == get_bitfield x lo hi `U.logxor` get_bitfield y lo hi) | [] | LowParse.BitFields.get_bitfield_logxor | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt.uint_t tot ->
y: FStar.UInt.uint_t tot ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot}
-> FStar.Pervasives.Lemma
(ensures
LowParse.BitFields.get_bitfield (FStar.UInt.logxor x y) lo hi ==
FStar.UInt.logxor (LowParse.BitFields.get_bitfield x lo hi)
(LowPar... | {
"end_col": 3,
"end_line": 230,
"start_col": 2,
"start_line": 226
} |
Prims.Tot | val bitfield_eq16_lhs (x: U16.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 16}) : Tot U16.t | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let bitfield_eq16_lhs
(x: U16.t) (lo: nat) (hi: nat {lo <= hi /\ hi <= 16})
: Tot U16.t
= x `U16.logand` bitfield_mask16 lo hi | val bitfield_eq16_lhs (x: U16.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 16}) : Tot U16.t
let bitfield_eq16_lhs (x: U16.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 16}) : Tot U16.t = | false | null | false | x `U16.logand` (bitfield_mask16 lo hi) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"FStar.UInt16.t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt16.logand",
"LowParse.BitFields.bitfield_mask16"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val bitfield_eq16_lhs (x: U16.t) (lo: nat) (hi: nat{lo <= hi /\ hi <= 16}) : Tot U16.t | [] | LowParse.BitFields.bitfield_eq16_lhs | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: FStar.UInt16.t -> lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= 16} -> FStar.UInt16.t | {
"end_col": 38,
"end_line": 1081,
"start_col": 2,
"start_line": 1081
} |
Prims.Tot | val not_bitfield_mask32 (lo: nat) (hi: nat{lo <= hi /\ hi <= 32})
: Tot (x: U32.t{U32.v x == not_bitfield_mask 32 lo hi}) | [
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt16",
"short_module": "U16"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.... | false | let not_bitfield_mask32 (lo: nat) (hi: nat { lo <= hi /\ hi <= 32 }) : Tot (x: U32.t { U32.v x == not_bitfield_mask 32 lo hi }) =
U32.lognot (bitfield_mask32 lo hi) | val not_bitfield_mask32 (lo: nat) (hi: nat{lo <= hi /\ hi <= 32})
: Tot (x: U32.t{U32.v x == not_bitfield_mask 32 lo hi})
let not_bitfield_mask32 (lo: nat) (hi: nat{lo <= hi /\ hi <= 32})
: Tot (x: U32.t{U32.v x == not_bitfield_mask 32 lo hi}) = | false | null | false | U32.lognot (bitfield_mask32 lo hi) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.lognot",
"LowParse.BitFields.bitfield_mask32",
"FStar.UInt32.t",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt32.v",
"LowParse.BitFields.not_bitfield_mask"
] | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val not_bitfield_mask32 (lo: nat) (hi: nat{lo <= hi /\ hi <= 32})
: Tot (x: U32.t{U32.v x == not_bitfield_mask 32 lo hi}) | [] | LowParse.BitFields.not_bitfield_mask32 | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | lo: Prims.nat -> hi: Prims.nat{lo <= hi /\ hi <= 32}
-> x: FStar.UInt32.t{FStar.UInt32.v x == LowParse.BitFields.not_bitfield_mask 32 lo hi} | {
"end_col": 36,
"end_line": 984,
"start_col": 2,
"start_line": 984
} |
FStar.Pervasives.Lemma | val get_bitfield_logor
(#tot: pos) (x y: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Lemma
(get_bitfield (x `U.logor` y) lo hi == get_bitfield x lo hi `U.logor` get_bitfield y lo hi) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "FStar.UInt",... | false | let get_bitfield_logor
(#tot: pos) (x y: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Lemma
(get_bitfield (x `U.logor` y) lo hi == get_bitfield x lo hi `U.logor` get_bitfield y lo hi)
= eq_nth (get_bitfield (x `U.logor` y) lo hi) (get_bitfield x lo hi `U.logor` get_bitfield y lo hi) (fun i ->
nth... | val get_bitfield_logor
(#tot: pos) (x y: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Lemma
(get_bitfield (x `U.logor` y) lo hi == get_bitfield x lo hi `U.logor` get_bitfield y lo hi)
let get_bitfield_logor (#tot: pos) (x y: U.uint_t tot) (lo: nat) (hi: nat{lo <= hi /\ hi <= tot})
: Lemma
(ge... | false | null | true | eq_nth (get_bitfield (x `U.logor` y) lo hi)
((get_bitfield x lo hi) `U.logor` (get_bitfield y lo hi))
(fun i ->
nth_get_bitfield (x `U.logor` y) lo hi i;
nth_get_bitfield x lo hi i;
nth_get_bitfield y lo hi i) | {
"checked_file": "LowParse.BitFields.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti... | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.BitFields.eq_nth",
"LowParse.BitFields.get_bitfield",
"FStar.UInt.logor",
"Prims.op_LessThan",
"LowParse.BitFields.nth_get_bitfield",
"Prims.unit",
"Prims.l_True",
"Prims.squash... | [] | module LowParse.BitFields
module U = FStar.UInt
module M = LowParse.Math
open FStar.Mul
inline_for_extraction
let bitfield_mask (tot: pos) (lo: nat) (hi: nat { lo <= hi /\ hi <= tot }) : Tot (U.uint_t tot) =
[@inline_let] let _ =
M.pow2_le_compat tot hi;
M.pow2_plus (hi - lo) lo
in
normalize_term ((pow2... | false | false | LowParse.BitFields.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val get_bitfield_logor
(#tot: pos) (x y: U.uint_t tot) (lo: nat) (hi: nat {lo <= hi /\ hi <= tot})
: Lemma
(get_bitfield (x `U.logor` y) lo hi == get_bitfield x lo hi `U.logor` get_bitfield y lo hi) | [] | LowParse.BitFields.get_bitfield_logor | {
"file_name": "src/lowparse/LowParse.BitFields.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
x: FStar.UInt.uint_t tot ->
y: FStar.UInt.uint_t tot ->
lo: Prims.nat ->
hi: Prims.nat{lo <= hi /\ hi <= tot}
-> FStar.Pervasives.Lemma
(ensures
LowParse.BitFields.get_bitfield (FStar.UInt.logor x y) lo hi ==
FStar.UInt.logor (LowParse.BitFields.get_bitfield x lo hi)
(LowParse... | {
"end_col": 3,
"end_line": 220,
"start_col": 2,
"start_line": 216
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.