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.Tot | val map (a:eqtype) (b:Type u#a) : Type u#a | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let map = map' | val map (a:eqtype) (b:Type u#a) : Type u#a
let map = | false | null | false | map' | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"total"
] | [
"Vale.Lib.MapTree.map'"
] | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b
let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h
let mkNode (#a:eqty... | false | true | Vale.Lib.MapTree.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 map (a:eqtype) (b:Type u#a) : Type u#a | [] | Vale.Lib.MapTree.map | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.eqtype -> b: Type -> Type | {
"end_col": 14,
"end_line": 144,
"start_col": 10,
"start_line": 144
} |
Prims.Tot | val mkNode (#a: eqtype) (#b: Type) (key: a) (value: b) (l r: tree a b) : tree a b | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let mkNode (#a:eqtype) (#b:Type) (key:a) (value:b) (l r:tree a b) : tree a b =
let hl = height l in
let hr = height r in
let h = if hl > hr then hl else hr in
Node key value (h + 1) l r | val mkNode (#a: eqtype) (#b: Type) (key: a) (value: b) (l r: tree a b) : tree a b
let mkNode (#a: eqtype) (#b: Type) (key: a) (value: b) (l r: tree a b) : tree a b = | false | null | false | let hl = height l in
let hr = height r in
let h = if hl > hr then hl else hr in
Node key value (h + 1) l r | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"total"
] | [
"Prims.eqtype",
"Vale.Lib.MapTree.tree",
"Vale.Lib.MapTree.Node",
"Prims.op_Addition",
"Prims.int",
"Prims.op_GreaterThan",
"Prims.bool",
"Prims.nat",
"Vale.Lib.MapTree.height"
] | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b
let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h | false | false | Vale.Lib.MapTree.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 mkNode (#a: eqtype) (#b: Type) (key: a) (value: b) (l r: tree a b) : tree a b | [] | Vale.Lib.MapTree.mkNode | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | key: a -> value: b -> l: Vale.Lib.MapTree.tree a b -> r: Vale.Lib.MapTree.tree a b
-> Vale.Lib.MapTree.tree a b | {
"end_col": 28,
"end_line": 19,
"start_col": 78,
"start_line": 15
} |
Prims.Tot | val height (#a: eqtype) (#b: Type) (t: tree a b) : nat | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h | val height (#a: eqtype) (#b: Type) (t: tree a b) : nat
let height (#a: eqtype) (#b: Type) (t: tree a b) : nat = | false | null | false | match t with
| Empty -> 0
| Node _ _ h _ _ -> h | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"total"
] | [
"Prims.eqtype",
"Vale.Lib.MapTree.tree",
"Prims.nat"
] | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b | false | false | Vale.Lib.MapTree.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 height (#a: eqtype) (#b: Type) (t: tree a b) : nat | [] | Vale.Lib.MapTree.height | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t: Vale.Lib.MapTree.tree a b -> Prims.nat | {
"end_col": 23,
"end_line": 13,
"start_col": 2,
"start_line": 11
} |
Prims.Tot | val sel (#a:eqtype) (#b:Type) (m:map a b) (key:a) : b | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let sel #a #b (Map is_le t d _) key =
match get is_le t key with Some v -> v | None -> d | val sel (#a:eqtype) (#b:Type) (m:map a b) (key:a) : b
let sel #a #b (Map is_le t d _) key = | false | null | false | match get is_le t key with
| Some v -> v
| None -> d | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"total"
] | [
"Prims.eqtype",
"Vale.Lib.MapTree.map",
"Prims.bool",
"Vale.Lib.MapTree.tree",
"Prims.squash",
"Prims.l_and",
"Vale.Lib.MapTree.is_cmp",
"Vale.Lib.MapTree.inv",
"FStar.Pervasives.Native.None",
"Vale.Lib.MapTree.get"
] | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b
let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h
let mkNode (#a:eqty... | false | false | Vale.Lib.MapTree.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 sel (#a:eqtype) (#b:Type) (m:map a b) (key:a) : b | [] | Vale.Lib.MapTree.sel | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Vale.Lib.MapTree.map a b -> key: a -> b | {
"end_col": 52,
"end_line": 150,
"start_col": 2,
"start_line": 150
} |
FStar.Pervasives.Lemma | val lemma_sel_upd_self (#a:eqtype) (#b:Type) (m:map a b) (key:a) (value:b) : Lemma
(ensures sel (upd m key value) key == value)
[SMTPat (sel (upd m key value) key)] | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let lemma_sel_upd_self #a #b (Map is_le t _ _) key value =
lemma_get_put_self is_le t key value None None | val lemma_sel_upd_self (#a:eqtype) (#b:Type) (m:map a b) (key:a) (value:b) : Lemma
(ensures sel (upd m key value) key == value)
[SMTPat (sel (upd m key value) key)]
let lemma_sel_upd_self #a #b (Map is_le t _ _) key value = | false | null | true | lemma_get_put_self is_le t key value None None | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"lemma"
] | [
"Prims.eqtype",
"Vale.Lib.MapTree.map",
"Prims.bool",
"Vale.Lib.MapTree.tree",
"Prims.squash",
"Prims.l_and",
"Vale.Lib.MapTree.is_cmp",
"Vale.Lib.MapTree.inv",
"FStar.Pervasives.Native.None",
"Vale.Lib.MapTree.lemma_get_put_self",
"Prims.unit"
] | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b
let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h
let mkNode (#a:eqty... | false | false | Vale.Lib.MapTree.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 lemma_sel_upd_self (#a:eqtype) (#b:Type) (m:map a b) (key:a) (value:b) : Lemma
(ensures sel (upd m key value) key == value)
[SMTPat (sel (upd m key value) key)] | [] | Vale.Lib.MapTree.lemma_sel_upd_self | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Vale.Lib.MapTree.map a b -> key: a -> value: b
-> FStar.Pervasives.Lemma
(ensures Vale.Lib.MapTree.sel (Vale.Lib.MapTree.upd m key value) key == value)
[SMTPat (Vale.Lib.MapTree.sel (Vale.Lib.MapTree.upd m key value) key)] | {
"end_col": 48,
"end_line": 161,
"start_col": 2,
"start_line": 161
} |
FStar.Pervasives.Lemma | val lemma_sel_upd_other (#a:eqtype) (#b:Type) (m:map a b) (key kx:a) (value:b) : Lemma
(requires key =!= kx)
(ensures sel (upd m key value) kx == sel m kx)
[SMTPat (sel (upd m key value) kx)] | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let lemma_sel_upd_other #a #b (Map is_le t _ _) key kx value =
lemma_get_put_other is_le t key kx value None None | val lemma_sel_upd_other (#a:eqtype) (#b:Type) (m:map a b) (key kx:a) (value:b) : Lemma
(requires key =!= kx)
(ensures sel (upd m key value) kx == sel m kx)
[SMTPat (sel (upd m key value) kx)]
let lemma_sel_upd_other #a #b (Map is_le t _ _) key kx value = | false | null | true | lemma_get_put_other is_le t key kx value None None | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"lemma"
] | [
"Prims.eqtype",
"Vale.Lib.MapTree.map",
"Prims.bool",
"Vale.Lib.MapTree.tree",
"Prims.squash",
"Prims.l_and",
"Vale.Lib.MapTree.is_cmp",
"Vale.Lib.MapTree.inv",
"FStar.Pervasives.Native.None",
"Vale.Lib.MapTree.lemma_get_put_other",
"Prims.unit"
] | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b
let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h
let mkNode (#a:eqty... | false | false | Vale.Lib.MapTree.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 lemma_sel_upd_other (#a:eqtype) (#b:Type) (m:map a b) (key kx:a) (value:b) : Lemma
(requires key =!= kx)
(ensures sel (upd m key value) kx == sel m kx)
[SMTPat (sel (upd m key value) kx)] | [] | Vale.Lib.MapTree.lemma_sel_upd_other | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Vale.Lib.MapTree.map a b -> key: a -> kx: a -> value: b
-> FStar.Pervasives.Lemma (requires ~(key == kx))
(ensures
Vale.Lib.MapTree.sel (Vale.Lib.MapTree.upd m key value) kx == Vale.Lib.MapTree.sel m kx)
[SMTPat (Vale.Lib.MapTree.sel (Vale.Lib.MapTree.upd m key value) kx)] | {
"end_col": 52,
"end_line": 164,
"start_col": 2,
"start_line": 164
} |
Prims.Tot | val const (a:eqtype) (b:Type) (is_le:(a -> a -> bool){is_cmp is_le}) (default_v:b) : map a b | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let const a b is_le d =
Map is_le Empty d () | val const (a:eqtype) (b:Type) (is_le:(a -> a -> bool){is_cmp is_le}) (default_v:b) : map a b
let const a b is_le d = | false | null | false | Map is_le Empty d () | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"total"
] | [
"Prims.eqtype",
"Prims.bool",
"Vale.Lib.MapTree.is_cmp",
"Vale.Lib.MapTree.Map",
"Vale.Lib.MapTree.Empty",
"Vale.Lib.MapTree.map"
] | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b
let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h
let mkNode (#a:eqty... | false | false | Vale.Lib.MapTree.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 const (a:eqtype) (b:Type) (is_le:(a -> a -> bool){is_cmp is_le}) (default_v:b) : map a b | [] | Vale.Lib.MapTree.const | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Prims.eqtype ->
b: Type ->
is_le: (_: a -> _: a -> Prims.bool){Vale.Lib.MapTree.is_cmp is_le} ->
default_v: b
-> Vale.Lib.MapTree.map a b | {
"end_col": 22,
"end_line": 147,
"start_col": 2,
"start_line": 147
} |
Prims.Tot | val get (#a: eqtype) (#b: Type) (is_le: (a -> a -> bool)) (t: tree a b) (key: a) : option b | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let rec get (#a:eqtype) (#b:Type) (is_le:a -> a -> bool) (t:tree a b) (key:a) : option b =
match t with
| Empty -> None
| Node k v h l r ->
if key = k then Some v
else if is_le key k then
get is_le l key
else
get is_le r key | val get (#a: eqtype) (#b: Type) (is_le: (a -> a -> bool)) (t: tree a b) (key: a) : option b
let rec get (#a: eqtype) (#b: Type) (is_le: (a -> a -> bool)) (t: tree a b) (key: a) : option b = | false | null | false | match t with
| Empty -> None
| Node k v h l r ->
if key = k then Some v else if is_le key k then get is_le l key else get is_le r key | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"total"
] | [
"Prims.eqtype",
"Prims.bool",
"Vale.Lib.MapTree.tree",
"FStar.Pervasives.Native.None",
"Prims.nat",
"Prims.op_Equality",
"FStar.Pervasives.Native.Some",
"Vale.Lib.MapTree.get",
"FStar.Pervasives.Native.option"
] | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b
let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h
let mkNode (#a:eqty... | false | false | Vale.Lib.MapTree.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 get (#a: eqtype) (#b: Type) (is_le: (a -> a -> bool)) (t: tree a b) (key: a) : option b | [
"recursion"
] | Vale.Lib.MapTree.get | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | is_le: (_: a -> _: a -> Prims.bool) -> t: Vale.Lib.MapTree.tree a b -> key: a
-> FStar.Pervasives.Native.option b | {
"end_col": 21,
"end_line": 49,
"start_col": 2,
"start_line": 42
} |
Prims.Tot | val upd (#a:eqtype) (#b:Type) (m:map a b) (key:a) (value:b) : map a b | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let upd #a #b (Map is_le t d _) key value =
let t' = put is_le t key value in
lemma_put_inv is_le t key value None None;
Map is_le t' d () | val upd (#a:eqtype) (#b:Type) (m:map a b) (key:a) (value:b) : map a b
let upd #a #b (Map is_le t d _) key value = | false | null | false | let t' = put is_le t key value in
lemma_put_inv is_le t key value None None;
Map is_le t' d () | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"total"
] | [
"Prims.eqtype",
"Vale.Lib.MapTree.map",
"Prims.bool",
"Vale.Lib.MapTree.tree",
"Prims.squash",
"Prims.l_and",
"Vale.Lib.MapTree.is_cmp",
"Vale.Lib.MapTree.inv",
"FStar.Pervasives.Native.None",
"Vale.Lib.MapTree.Map",
"Prims.unit",
"Vale.Lib.MapTree.lemma_put_inv",
"Vale.Lib.MapTree.put"
] | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b
let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h
let mkNode (#a:eqty... | false | false | Vale.Lib.MapTree.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 upd (#a:eqtype) (#b:Type) (m:map a b) (key:a) (value:b) : map a b | [] | Vale.Lib.MapTree.upd | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Vale.Lib.MapTree.map a b -> key: a -> value: b -> Vale.Lib.MapTree.map a b | {
"end_col": 19,
"end_line": 155,
"start_col": 43,
"start_line": 152
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let rec inv (#a:eqtype) (#b:Type) (is_le:a -> a -> bool) (t:tree a b) (lo hi:option a) =
let (<) x y = is_lt_option is_le x y in
match t with
| Empty -> True
| Node x _ _ l r ->
let x = Some x in
lo < x /\ x < hi /\ inv is_le l lo x /\ inv is_le r x hi | let rec inv (#a: eqtype) (#b: Type) (is_le: (a -> a -> bool)) (t: tree a b) (lo hi: option a) = | false | null | false | let op_Less x y = is_lt_option is_le x y in
match t with
| Empty -> True
| Node x _ _ l r ->
let x = Some x in
lo < x /\ x < hi /\ inv is_le l lo x /\ inv is_le r x hi | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"total"
] | [
"Prims.eqtype",
"Prims.bool",
"Vale.Lib.MapTree.tree",
"FStar.Pervasives.Native.option",
"Prims.l_True",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Vale.Lib.MapTree.inv",
"FStar.Pervasives.Native.Some",
"Prims.logical",
"Vale.Lib.MapTree.is_lt_option"
] | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b
let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h
let mkNode (#a:eqty... | false | false | Vale.Lib.MapTree.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 inv : is_le: (_: a -> _: a -> Prims.bool) ->
t: Vale.Lib.MapTree.tree a b ->
lo: FStar.Pervasives.Native.option a ->
hi: FStar.Pervasives.Native.option a
-> Prims.logical | [
"recursion"
] | Vale.Lib.MapTree.inv | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
is_le: (_: a -> _: a -> Prims.bool) ->
t: Vale.Lib.MapTree.tree a b ->
lo: FStar.Pervasives.Native.option a ->
hi: FStar.Pervasives.Native.option a
-> Prims.logical | {
"end_col": 60,
"end_line": 74,
"start_col": 88,
"start_line": 68
} | |
Prims.Tot | val put (#a: eqtype) (#b: Type) (is_le: (a -> a -> bool)) (t: tree a b) (key: a) (value: b)
: tree a b | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let rec put (#a:eqtype) (#b:Type) (is_le:a -> a -> bool) (t:tree a b) (key:a) (value:b) : tree a b =
match t with
| Empty -> mkNode key value Empty Empty
| Node k v _ l r ->
if key = k then mkNode k value l r
else if is_le key k then
balance (mkNode k v (put is_le l key value) r)
else
bala... | val put (#a: eqtype) (#b: Type) (is_le: (a -> a -> bool)) (t: tree a b) (key: a) (value: b)
: tree a b
let rec put (#a: eqtype) (#b: Type) (is_le: (a -> a -> bool)) (t: tree a b) (key: a) (value: b)
: tree a b = | false | null | false | match t with
| Empty -> mkNode key value Empty Empty
| Node k v _ l r ->
if key = k
then mkNode k value l r
else
if is_le key k
then balance (mkNode k v (put is_le l key value) r)
else balance (mkNode k v l (put is_le r key value)) | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"total"
] | [
"Prims.eqtype",
"Prims.bool",
"Vale.Lib.MapTree.tree",
"Vale.Lib.MapTree.mkNode",
"Vale.Lib.MapTree.Empty",
"Prims.nat",
"Prims.op_Equality",
"Vale.Lib.MapTree.balance",
"Vale.Lib.MapTree.put"
] | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b
let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h
let mkNode (#a:eqty... | false | false | Vale.Lib.MapTree.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 put (#a: eqtype) (#b: Type) (is_le: (a -> a -> bool)) (t: tree a b) (key: a) (value: b)
: tree a b | [
"recursion"
] | Vale.Lib.MapTree.put | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | is_le: (_: a -> _: a -> Prims.bool) -> t: Vale.Lib.MapTree.tree a b -> key: a -> value: b
-> Vale.Lib.MapTree.tree a b | {
"end_col": 52,
"end_line": 59,
"start_col": 2,
"start_line": 52
} |
FStar.Pervasives.Lemma | val lemma_get_put_self
(#a: eqtype)
(#b: Type)
(is_le: (a -> a -> bool))
(t: tree a b)
(key: a)
(value: b)
(lo hi: option a)
: Lemma (requires is_cmp is_le /\ inv is_le t lo hi)
(ensures get is_le (put is_le t key value) key == Some value) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let rec lemma_get_put_self (#a:eqtype) (#b:Type) (is_le:a -> a -> bool) (t:tree a b) (key:a) (value:b) (lo hi:option a) : Lemma
(requires is_cmp is_le /\ inv is_le t lo hi)
(ensures get is_le (put is_le t key value) key == Some value)
=
match t with
| Empty -> ()
| Node k v _ l r ->
if key = k then ()
... | val lemma_get_put_self
(#a: eqtype)
(#b: Type)
(is_le: (a -> a -> bool))
(t: tree a b)
(key: a)
(value: b)
(lo hi: option a)
: Lemma (requires is_cmp is_le /\ inv is_le t lo hi)
(ensures get is_le (put is_le t key value) key == Some value)
let rec lemma_get_put_self
... | false | null | true | match t with
| Empty -> ()
| Node k v _ l r ->
if key = k
then ()
else
if is_le key k
then lemma_get_put_self is_le l key value lo (Some k)
else lemma_get_put_self is_le r key value (Some k) hi | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"lemma"
] | [
"Prims.eqtype",
"Prims.bool",
"Vale.Lib.MapTree.tree",
"FStar.Pervasives.Native.option",
"Prims.nat",
"Prims.op_Equality",
"Vale.Lib.MapTree.lemma_get_put_self",
"FStar.Pervasives.Native.Some",
"Prims.unit",
"Prims.l_and",
"Vale.Lib.MapTree.is_cmp",
"Vale.Lib.MapTree.inv",
"Prims.squash",
... | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b
let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h
let mkNode (#a:eqty... | false | false | Vale.Lib.MapTree.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 2,
"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 lemma_get_put_self
(#a: eqtype)
(#b: Type)
(is_le: (a -> a -> bool))
(t: tree a b)
(key: a)
(value: b)
(lo hi: option a)
: Lemma (requires is_cmp is_le /\ inv is_le t lo hi)
(ensures get is_le (put is_le t key value) key == Some value) | [
"recursion"
] | Vale.Lib.MapTree.lemma_get_put_self | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
is_le: (_: a -> _: a -> Prims.bool) ->
t: Vale.Lib.MapTree.tree a b ->
key: a ->
value: b ->
lo: FStar.Pervasives.Native.option a ->
hi: FStar.Pervasives.Native.option a
-> FStar.Pervasives.Lemma
(requires Vale.Lib.MapTree.is_cmp is_le /\ Vale.Lib.MapTree.inv is_le t lo hi)
(ensur... | {
"end_col": 54,
"end_line": 107,
"start_col": 2,
"start_line": 100
} |
FStar.Pervasives.Lemma | val lemma_put_inv
(#a: eqtype)
(#b: Type)
(is_le: (a -> a -> bool))
(t: tree a b)
(key: a)
(value: b)
(lo hi: option a)
: Lemma
(requires
is_cmp is_le /\ inv is_le t lo hi /\ is_lt_option is_le lo (Some key) /\
is_lt_option is_le (Some key) hi) (ensure... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let rec lemma_put_inv (#a:eqtype) (#b:Type) (is_le:a -> a -> bool) (t:tree a b) (key:a) (value:b) (lo hi:option a)
: Lemma
(requires
is_cmp is_le /\
inv is_le t lo hi /\
is_lt_option is_le lo (Some key) /\
is_lt_option is_le (Some key) hi
)
(ensures inv is_le (put is_le t key value... | val lemma_put_inv
(#a: eqtype)
(#b: Type)
(is_le: (a -> a -> bool))
(t: tree a b)
(key: a)
(value: b)
(lo hi: option a)
: Lemma
(requires
is_cmp is_le /\ inv is_le t lo hi /\ is_lt_option is_le lo (Some key) /\
is_lt_option is_le (Some key) hi) (ensure... | false | null | true | match t with
| Empty -> ()
| Node k v _ l r ->
if key = k
then ()
else
if is_le key k
then lemma_put_inv is_le l key value lo (Some k)
else lemma_put_inv is_le r key value (Some k) hi | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"lemma"
] | [
"Prims.eqtype",
"Prims.bool",
"Vale.Lib.MapTree.tree",
"FStar.Pervasives.Native.option",
"Prims.nat",
"Prims.op_Equality",
"Vale.Lib.MapTree.lemma_put_inv",
"FStar.Pervasives.Native.Some",
"Prims.unit",
"Prims.l_and",
"Vale.Lib.MapTree.is_cmp",
"Vale.Lib.MapTree.inv",
"Prims.b2t",
"Vale.Li... | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b
let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h
let mkNode (#a:eqty... | false | false | Vale.Lib.MapTree.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 2,
"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 lemma_put_inv
(#a: eqtype)
(#b: Type)
(is_le: (a -> a -> bool))
(t: tree a b)
(key: a)
(value: b)
(lo hi: option a)
: Lemma
(requires
is_cmp is_le /\ inv is_le t lo hi /\ is_lt_option is_le lo (Some key) /\
is_lt_option is_le (Some key) hi) (ensure... | [
"recursion"
] | Vale.Lib.MapTree.lemma_put_inv | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
is_le: (_: a -> _: a -> Prims.bool) ->
t: Vale.Lib.MapTree.tree a b ->
key: a ->
value: b ->
lo: FStar.Pervasives.Native.option a ->
hi: FStar.Pervasives.Native.option a
-> FStar.Pervasives.Lemma
(requires
Vale.Lib.MapTree.is_cmp is_le /\ Vale.Lib.MapTree.inv is_le t lo hi /\
... | {
"end_col": 49,
"end_line": 94,
"start_col": 2,
"start_line": 87
} |
FStar.Pervasives.Lemma | val lemma_get_put_other
(#a: eqtype)
(#b: Type)
(is_le: (a -> a -> bool))
(t: tree a b)
(key kx: a)
(value: b)
(lo hi: option a)
: Lemma
(requires
is_cmp is_le /\ inv is_le t lo hi /\ is_lt_option is_le lo (Some key) /\
is_lt_option is_le (Some key) hi... | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib",
... | false | let rec lemma_get_put_other (#a:eqtype) (#b:Type) (is_le:a -> a -> bool) (t:tree a b) (key kx:a) (value:b) (lo hi:option a)
: Lemma
(requires
is_cmp is_le /\
inv is_le t lo hi /\
is_lt_option is_le lo (Some key) /\
is_lt_option is_le (Some key) hi /\
key =!= kx
)
(ensures get... | val lemma_get_put_other
(#a: eqtype)
(#b: Type)
(is_le: (a -> a -> bool))
(t: tree a b)
(key kx: a)
(value: b)
(lo hi: option a)
: Lemma
(requires
is_cmp is_le /\ inv is_le t lo hi /\ is_lt_option is_le lo (Some key) /\
is_lt_option is_le (Some key) hi... | false | null | true | lemma_put_inv is_le t key value lo hi;
match t with
| Empty -> ()
| Node k v _ l r ->
if key = k
then ()
else
if is_le key k
then lemma_get_put_other is_le l key kx value lo (Some k)
else lemma_get_put_other is_le r key kx value (Some k) hi | {
"checked_file": "Vale.Lib.MapTree.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Lib.MapTree.fst"
} | [
"lemma"
] | [
"Prims.eqtype",
"Prims.bool",
"Vale.Lib.MapTree.tree",
"FStar.Pervasives.Native.option",
"Prims.nat",
"Prims.op_Equality",
"Vale.Lib.MapTree.lemma_get_put_other",
"FStar.Pervasives.Native.Some",
"Prims.unit",
"Vale.Lib.MapTree.lemma_put_inv",
"Prims.l_and",
"Vale.Lib.MapTree.is_cmp",
"Vale.L... | [] | module Vale.Lib.MapTree
open FStar.Mul
(** Balanced tree implementation *)
type tree (a:eqtype) (b:Type) =
| Empty : tree a b
| Node : a -> b -> nat -> tree a b -> tree a b -> tree a b
let height (#a:eqtype) (#b:Type) (t:tree a b) : nat =
match t with
| Empty -> 0
| Node _ _ h _ _ -> h
let mkNode (#a:eqty... | false | false | Vale.Lib.MapTree.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 2,
"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 lemma_get_put_other
(#a: eqtype)
(#b: Type)
(is_le: (a -> a -> bool))
(t: tree a b)
(key kx: a)
(value: b)
(lo hi: option a)
: Lemma
(requires
is_cmp is_le /\ inv is_le t lo hi /\ is_lt_option is_le lo (Some key) /\
is_lt_option is_le (Some key) hi... | [
"recursion"
] | Vale.Lib.MapTree.lemma_get_put_other | {
"file_name": "vale/code/lib/collections/Vale.Lib.MapTree.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
is_le: (_: a -> _: a -> Prims.bool) ->
t: Vale.Lib.MapTree.tree a b ->
key: a ->
kx: a ->
value: b ->
lo: FStar.Pervasives.Native.option a ->
hi: FStar.Pervasives.Native.option a
-> FStar.Pervasives.Lemma
(requires
Vale.Lib.MapTree.is_cmp is_le /\ Vale.Lib.MapTree.inv is_le ... | {
"end_col": 58,
"end_line": 128,
"start_col": 2,
"start_line": 120
} |
Prims.Tot | val pow2_63:nat | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": ... | false | let pow2_63:nat = 0x8000000000000000 | val pow2_63:nat
let pow2_63:nat = | false | null | false | 0x8000000000000000 | {
"checked_file": "Vale.Curve25519.FastHybrid_helpers.fsti.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"prims.fst.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.Tactics.fst.checked",
... | [
"total"
] | [] | [] | module Vale.Curve25519.FastHybrid_helpers
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open FStar.Tactics
open FStar.Tactics.CanonCommSemiring
open Vale.Curve25519.Fast_defs
open FStar.Calc
let int_canon = fun _ -> norm [delta; zeta; iota]; int_semiring () //; dump "Final" | false | true | Vale.Curve25519.FastHybrid_helpers.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pow2_63:nat | [] | Vale.Curve25519.FastHybrid_helpers.pow2_63 | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.FastHybrid_helpers.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.nat | {
"end_col": 43,
"end_line": 13,
"start_col": 25,
"start_line": 13
} |
FStar.Tactics.Effect.Tac | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": ... | false | let int_canon = fun _ -> norm [delta; zeta; iota]; int_semiring () | let int_canon = | true | null | false | fun _ ->
norm [delta; zeta; iota];
int_semiring () | {
"checked_file": "Vale.Curve25519.FastHybrid_helpers.fsti.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"prims.fst.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.Tactics.fst.checked",
... | [] | [
"FStar.Tactics.CanonCommSemiring.int_semiring",
"Prims.unit",
"FStar.Tactics.V1.Builtins.norm",
"Prims.Cons",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.delta",
"FStar.Pervasives.zeta",
"FStar.Pervasives.iota",
"Prims.Nil"
] | [] | module Vale.Curve25519.FastHybrid_helpers
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open FStar.Tactics
open FStar.Tactics.CanonCommSemiring
open Vale.Curve25519.Fast_defs
open FStar.Calc | false | false | Vale.Curve25519.FastHybrid_helpers.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val int_canon : _: _ -> FStar.Tactics.Effect.Tac Prims.unit | [] | Vale.Curve25519.FastHybrid_helpers.int_canon | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.FastHybrid_helpers.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: _ -> FStar.Tactics.Effect.Tac Prims.unit | {
"end_col": 66,
"end_line": 11,
"start_col": 16,
"start_line": 11
} | |
FStar.Pervasives.Lemma | val lemma_mul_pow256_add (x y: nat) : Lemma ((x + y * pow2_256) % prime == (x + y * 38) % prime) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_defs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommSemiring",
"short_module": null
},
{
"abbrev": ... | false | let lemma_mul_pow256_add (x y:nat) :
Lemma ((x + y * pow2_256) % prime == (x + y * 38) % prime)
=
assert_norm (pow2_256 % prime == 38);
() | val lemma_mul_pow256_add (x y: nat) : Lemma ((x + y * pow2_256) % prime == (x + y * 38) % prime)
let lemma_mul_pow256_add (x y: nat) : Lemma ((x + y * pow2_256) % prime == (x + y * 38) % prime) = | false | null | true | assert_norm (pow2_256 % prime == 38);
() | {
"checked_file": "Vale.Curve25519.FastHybrid_helpers.fsti.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_defs.fst.checked",
"prims.fst.checked",
"FStar.Tactics.CanonCommSemiring.fst.checked",
"FStar.Tactics.fst.checked",
... | [
"lemma"
] | [
"Prims.nat",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Vale.Curve25519.Fast_defs.pow2_256",
"Vale.Curve25519.Fast_defs.prime",
"Prims.l_True",
"Prims.squash",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.Nil",
"FStar.Pervasives.pattern... | [] | module Vale.Curve25519.FastHybrid_helpers
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open FStar.Tactics
open FStar.Tactics.CanonCommSemiring
open Vale.Curve25519.Fast_defs
open FStar.Calc
let int_canon = fun _ -> norm [delta; zeta; iota]; int_semiring () //; dump "Final"
unfold let pow2_63:nat = 0x80... | false | false | Vale.Curve25519.FastHybrid_helpers.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_mul_pow256_add (x y: nat) : Lemma ((x + y * pow2_256) % prime == (x + y * 38) % prime) | [] | Vale.Curve25519.FastHybrid_helpers.lemma_mul_pow256_add | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.FastHybrid_helpers.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Prims.nat -> y: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
(x + y * Vale.Curve25519.Fast_defs.pow2_256) % Vale.Curve25519.Fast_defs.prime ==
(x + y * 38) % Vale.Curve25519.Fast_defs.prime) | {
"end_col": 4,
"end_line": 21,
"start_col": 2,
"start_line": 20
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_mod... | false | let inverses #a #b
(f: (a -> GTot b))
(g: (b -> GTot a)) =
(forall x. g (f x) == x) /\
(forall y. f (g y) == y) | let inverses #a #b (f: (a -> GTot b)) (g: (b -> GTot a)) = | false | null | false | (forall x. g (f x) == x) /\ (forall y. f (g y) == y) | {
"checked_file": "LowStar.BufferView.Down.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
... | [
"total"
] | [
"Prims.l_and",
"Prims.l_Forall",
"Prims.eq2",
"Prims.logical"
] | [] | (*
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.BufferView.Down.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 inverses : f: (_: a -> Prims.GTot b) -> g: (_: b -> Prims.GTot a) -> Prims.logical | [] | LowStar.BufferView.Down.inverses | {
"file_name": "ulib/LowStar.BufferView.Down.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: a -> Prims.GTot b) -> g: (_: b -> Prims.GTot a) -> Prims.logical | {
"end_col": 26,
"end_line": 48,
"start_col": 2,
"start_line": 47
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
... | false | let as_buffer_t (#dest:Type) (b:buffer dest) = B.mbuffer (Mkdtuple4?._1 b) (Mkdtuple4?._2 b) (Mkdtuple4?._3 b) | let as_buffer_t (#dest: Type) (b: buffer dest) = | false | null | false | B.mbuffer (Mkdtuple4?._1 b) (Mkdtuple4?._2 b) (Mkdtuple4?._3 b) | {
"checked_file": "LowStar.BufferView.Down.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
... | [
"total"
] | [
"LowStar.BufferView.Down.buffer",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.Pervasives.__proj__Mkdtuple4__item___1",
"LowStar.Monotonic.Buffer.srel",
"LowStar.BufferView.Down.buffer_view",
"FStar.Pervasives.__proj__Mkdtuple4__item___2",
"FStar.Pervasives.__proj__Mkdtuple4__item___3"
] | [] | (*
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.BufferView.Down.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 as_buffer_t : b: LowStar.BufferView.Down.buffer dest -> Type0 | [] | LowStar.BufferView.Down.as_buffer_t | {
"file_name": "ulib/LowStar.BufferView.Down.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | b: LowStar.BufferView.Down.buffer dest -> Type0 | {
"end_col": 110,
"end_line": 88,
"start_col": 47,
"start_line": 88
} | |
Prims.Tot | val buffer (dest: Type u#a) : Type u#(max 1 a) | [
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
... | false | let buffer (dest:Type u#a) : Type u#(max 1 a) = (src:Type0 & rrel:B.srel src & rel:B.srel src & buffer_view src rrel rel dest) | val buffer (dest: Type u#a) : Type u#(max 1 a)
let buffer (dest: Type u#a) : Type u#(max 1 a) = | false | null | false | (src: Type0 & rrel: B.srel src & rel: B.srel src & buffer_view src rrel rel dest) | {
"checked_file": "LowStar.BufferView.Down.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
... | [
"total"
] | [
"FStar.Pervasives.dtuple4",
"LowStar.Monotonic.Buffer.srel",
"LowStar.BufferView.Down.buffer_view"
] | [] | (*
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 | true | LowStar.BufferView.Down.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 buffer (dest: Type u#a) : Type u#(max 1 a) | [] | LowStar.BufferView.Down.buffer | {
"file_name": "ulib/LowStar.BufferView.Down.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | dest: Type -> Type | {
"end_col": 126,
"end_line": 86,
"start_col": 48,
"start_line": 86
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
... | false | let live #b h (vb:buffer b) = live h (as_buffer vb) | let live #b h (vb: buffer b) = | false | null | false | live h (as_buffer vb) | {
"checked_file": "LowStar.BufferView.Down.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
... | [
"total"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowStar.BufferView.Down.buffer",
"LowStar.Monotonic.Buffer.live",
"FStar.Pervasives.__proj__Mkdtuple4__item___1",
"LowStar.Monotonic.Buffer.srel",
"LowStar.BufferView.Down.buffer_view",
"FStar.Pervasives.__proj__Mkdtuple4__item___2",
"FStar.Pervasives.__proj__Mkdtupl... | [] | (*
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.BufferView.Down.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 live : h: FStar.Monotonic.HyperStack.mem -> vb: LowStar.BufferView.Down.buffer b -> Type0 | [] | LowStar.BufferView.Down.live | {
"file_name": "ulib/LowStar.BufferView.Down.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | h: FStar.Monotonic.HyperStack.mem -> vb: LowStar.BufferView.Down.buffer b -> Type0 | {
"end_col": 51,
"end_line": 126,
"start_col": 30,
"start_line": 126
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
... | false | let modifies (#b: _)
(vb:buffer b)
(h h':HS.mem)
= B.modifies (B.loc_buffer (as_buffer vb)) h h' | let modifies (#b: _) (vb: buffer b) (h h': HS.mem) = | false | null | false | B.modifies (B.loc_buffer (as_buffer vb)) h h' | {
"checked_file": "LowStar.BufferView.Down.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
... | [
"total"
] | [
"LowStar.BufferView.Down.buffer",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_buffer",
"FStar.Pervasives.__proj__Mkdtuple4__item___1",
"LowStar.Monotonic.Buffer.srel",
"LowStar.BufferView.Down.buffer_view",
"FStar.Pervasives.__proj__Mkdtuple4__i... | [] | (*
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.BufferView.Down.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 modifies : vb: LowStar.BufferView.Down.buffer b ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem
-> Type0 | [] | LowStar.BufferView.Down.modifies | {
"file_name": "ulib/LowStar.BufferView.Down.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
vb: LowStar.BufferView.Down.buffer b ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem
-> Type0 | {
"end_col": 51,
"end_line": 193,
"start_col": 6,
"start_line": 193
} | |
Prims.Tot | val from_list_be (l: list bool) : int | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot.Properties",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "List"
},
{
"abbrev": false,
"full_... | false | let from_list_be (l:list bool) : int =
from_list_le (List.rev l) | val from_list_be (l: list bool) : int
let from_list_be (l: list bool) : int = | false | null | false | from_list_le (List.rev l) | {
"checked_file": "Vale.Lib.Lists.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_fi... | [
"total"
] | [
"Prims.list",
"Prims.bool",
"Vale.Lib.Lists.from_list_le",
"FStar.List.Tot.Base.rev",
"Prims.int"
] | [] | module Vale.Lib.Lists
open FStar.List.Tot
open FStar.Seq
open FStar.UInt
open FStar.Mul
module List = FStar.List.Tot
open FStar.List.Tot.Properties
val singleton_list_rev (#a:Type) (x:a) : Lemma
(List.rev [x] == [x])
val list_cons_is_append (#a:Type) (h:a) (t:list a) : Lemma
(h::t == [h] @ t)
val singleton_list... | false | true | Vale.Lib.Lists.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val from_list_be (l: list bool) : int | [] | Vale.Lib.Lists.from_list_be | {
"file_name": "vale/code/lib/collections/Vale.Lib.Lists.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | l: Prims.list Prims.bool -> Prims.int | {
"end_col": 27,
"end_line": 39,
"start_col": 2,
"start_line": 39
} |
Prims.Tot | val from_list_le (l: list bool) : int | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot.Properties",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "List"
},
{
"abbrev": false,
"full_... | false | let rec from_list_le (l:list bool) : int =
match l with
| [] -> 0
| h::t -> (if h then 1 else 0) + 2 * (from_list_le t) | val from_list_le (l: list bool) : int
let rec from_list_le (l: list bool) : int = | false | null | false | match l with
| [] -> 0
| h :: t -> (if h then 1 else 0) + 2 * (from_list_le t) | {
"checked_file": "Vale.Lib.Lists.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_fi... | [
"total"
] | [
"Prims.list",
"Prims.bool",
"Prims.op_Addition",
"Prims.int",
"FStar.Mul.op_Star",
"Vale.Lib.Lists.from_list_le"
] | [] | module Vale.Lib.Lists
open FStar.List.Tot
open FStar.Seq
open FStar.UInt
open FStar.Mul
module List = FStar.List.Tot
open FStar.List.Tot.Properties
val singleton_list_rev (#a:Type) (x:a) : Lemma
(List.rev [x] == [x])
val list_cons_is_append (#a:Type) (h:a) (t:list a) : Lemma
(h::t == [h] @ t)
val singleton_list... | false | true | Vale.Lib.Lists.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val from_list_le (l: list bool) : int | [
"recursion"
] | Vale.Lib.Lists.from_list_le | {
"file_name": "vale/code/lib/collections/Vale.Lib.Lists.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | l: Prims.list Prims.bool -> Prims.int | {
"end_col": 55,
"end_line": 36,
"start_col": 2,
"start_line": 34
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let aff_point_inv (h:mem) (p:aff_point) =
aff_point_inv_seq (as_seq h p) | let aff_point_inv (h: mem) (p: aff_point) = | false | null | false | aff_point_inv_seq (as_seq h p) | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"total"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.P256.Point.aff_point",
"Hacl.Impl.P256.Point.aff_point_inv_seq",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Prims.logical"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | true | Hacl.Impl.P256.Point.fsti | {
"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 aff_point_inv : h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.P256.Point.aff_point -> Prims.logical | [] | Hacl.Impl.P256.Point.aff_point_inv | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.P256.Point.aff_point -> Prims.logical | {
"end_col": 32,
"end_line": 46,
"start_col": 2,
"start_line": 46
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let aff_point_inv_seq (p:aff_point_seq) =
let x, y = as_aff_point_nat_seq p in
x < S.prime /\ y < S.prime | let aff_point_inv_seq (p: aff_point_seq) = | false | null | false | let x, y = as_aff_point_nat_seq p in
x < S.prime /\ y < S.prime | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"total"
] | [
"Hacl.Impl.P256.Point.aff_point_seq",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.P256.PointOps.prime",
"Prims.logical",
"FStar.Pervasives.Native.tuple2",
"Hacl.Impl.P256.Point.as_aff_point_nat_seq"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | true | Hacl.Impl.P256.Point.fsti | {
"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 aff_point_inv_seq : p: Hacl.Impl.P256.Point.aff_point_seq -> Prims.logical | [] | Hacl.Impl.P256.Point.aff_point_inv_seq | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Impl.P256.Point.aff_point_seq -> Prims.logical | {
"end_col": 28,
"end_line": 34,
"start_col": 41,
"start_line": 32
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let aff_point = lbuffer uint64 8ul | let aff_point = | false | null | false | lbuffer uint64 8ul | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"total"
] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | true | Hacl.Impl.P256.Point.fsti | {
"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 aff_point : Type0 | [] | Hacl.Impl.P256.Point.aff_point | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 34,
"end_line": 38,
"start_col": 16,
"start_line": 38
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let point_inv (h:mem) (p:point) =
point_inv_seq (as_seq h p) | let point_inv (h: mem) (p: point) = | false | null | false | point_inv_seq (as_seq h p) | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"total"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Point.point_inv_seq",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Prims.logical"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | true | Hacl.Impl.P256.Point.fsti | {
"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 point_inv : h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.P256.Point.point -> Prims.logical | [] | Hacl.Impl.P256.Point.point_inv | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.P256.Point.point -> Prims.logical | {
"end_col": 28,
"end_line": 93,
"start_col": 2,
"start_line": 93
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let point_inv_seq (p:point_seq) =
let x, y, z = as_point_nat_seq p in
x < S.prime /\ y < S.prime /\ z < S.prime | let point_inv_seq (p: point_seq) = | false | null | false | let x, y, z = as_point_nat_seq p in
x < S.prime /\ y < S.prime /\ z < S.prime | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"total"
] | [
"Hacl.Impl.P256.Point.point_seq",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.P256.PointOps.prime",
"Prims.logical",
"FStar.Pervasives.Native.tuple3",
"Hacl.Impl.P256.Point.as_point_nat_seq"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | true | Hacl.Impl.P256.Point.fsti | {
"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 point_inv_seq : p: Hacl.Impl.P256.Point.point_seq -> Prims.logical | [] | Hacl.Impl.P256.Point.point_inv_seq | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Impl.P256.Point.point_seq -> Prims.logical | {
"end_col": 43,
"end_line": 81,
"start_col": 33,
"start_line": 79
} | |
Prims.GTot | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let as_aff_point_nat (h:mem) (p:aff_point) =
as_aff_point_nat_seq (as_seq h p) | let as_aff_point_nat (h: mem) (p: aff_point) = | false | null | false | as_aff_point_nat_seq (as_seq h p) | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.P256.Point.aff_point",
"Hacl.Impl.P256.Point.as_aff_point_nat_seq",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"FStar.Pervasives.Native.tuple2",
"Prims.nat"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | false | Hacl.Impl.P256.Point.fsti | {
"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 as_aff_point_nat : h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.P256.Point.aff_point
-> Prims.GTot (Prims.nat * Prims.nat) | [] | Hacl.Impl.P256.Point.as_aff_point_nat | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.P256.Point.aff_point
-> Prims.GTot (Prims.nat * Prims.nat) | {
"end_col": 35,
"end_line": 42,
"start_col": 2,
"start_line": 42
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let point = lbuffer uint64 12ul | let point = | false | null | false | lbuffer uint64 12ul | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"total"
] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | true | Hacl.Impl.P256.Point.fsti | {
"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 point : Type0 | [] | Hacl.Impl.P256.Point.point | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 31,
"end_line": 85,
"start_col": 12,
"start_line": 85
} | |
Prims.GTot | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let as_point_nat (h:mem) (p:point) =
as_point_nat_seq (as_seq h p) | let as_point_nat (h: mem) (p: point) = | false | null | false | as_point_nat_seq (as_seq h p) | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Point.as_point_nat_seq",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"FStar.Pervasives.Native.tuple3",
"Prims.nat"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | false | Hacl.Impl.P256.Point.fsti | {
"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 as_point_nat : h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.P256.Point.point
-> Prims.GTot ((Prims.nat * Prims.nat) * Prims.nat) | [] | Hacl.Impl.P256.Point.as_point_nat | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.P256.Point.point
-> Prims.GTot ((Prims.nat * Prims.nat) * Prims.nat) | {
"end_col": 31,
"end_line": 89,
"start_col": 2,
"start_line": 89
} | |
Prims.Tot | val from_mont_point (a: tuple3 nat nat nat) : S.proj_point | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let from_mont_point (a:tuple3 nat nat nat) : S.proj_point =
let x, y, z = a in SM.from_mont x, SM.from_mont y, SM.from_mont z | val from_mont_point (a: tuple3 nat nat nat) : S.proj_point
let from_mont_point (a: tuple3 nat nat nat) : S.proj_point = | false | null | false | let x, y, z = a in
SM.from_mont x, SM.from_mont y, SM.from_mont z | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"total"
] | [
"FStar.Pervasives.Native.tuple3",
"Prims.nat",
"FStar.Pervasives.Native.Mktuple3",
"Hacl.Spec.P256.Montgomery.from_mont",
"Spec.P256.PointOps.proj_point"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | true | Hacl.Impl.P256.Point.fsti | {
"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 from_mont_point (a: tuple3 nat nat nat) : S.proj_point | [] | Hacl.Impl.P256.Point.from_mont_point | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: ((Prims.nat * Prims.nat) * Prims.nat) -> Spec.P256.PointOps.proj_point | {
"end_col": 67,
"end_line": 20,
"start_col": 59,
"start_line": 19
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let aff_point_seq = LSeq.lseq uint64 8 | let aff_point_seq = | false | null | false | LSeq.lseq uint64 8 | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"total"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | true | Hacl.Impl.P256.Point.fsti | {
"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 aff_point_seq : Type0 | [] | Hacl.Impl.P256.Point.aff_point_seq | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 38,
"end_line": 26,
"start_col": 20,
"start_line": 26
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let point_seq = LSeq.lseq uint64 12 | let point_seq = | false | null | false | LSeq.lseq uint64 12 | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"total"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | true | Hacl.Impl.P256.Point.fsti | {
"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 point_seq : Type0 | [] | Hacl.Impl.P256.Point.point_seq | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 35,
"end_line": 72,
"start_col": 16,
"start_line": 72
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let as_aff_point_nat_seq (p:aff_point_seq) =
BD.bn_v (LSeq.sub p 0 4),
BD.bn_v (LSeq.sub p 4 4) | let as_aff_point_nat_seq (p: aff_point_seq) = | false | null | false | BD.bn_v (LSeq.sub p 0 4), BD.bn_v (LSeq.sub p 4 4) | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"total"
] | [
"Hacl.Impl.P256.Point.aff_point_seq",
"FStar.Pervasives.Native.Mktuple2",
"Prims.nat",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.IntTypes.U64",
"Lib.Sequence.sub",
"Lib.IntTypes.uint64",
"FStar.Pervasives.Native.tuple2"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | true | Hacl.Impl.P256.Point.fsti | {
"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 as_aff_point_nat_seq : p: Hacl.Impl.P256.Point.aff_point_seq -> Prims.nat * Prims.nat | [] | Hacl.Impl.P256.Point.as_aff_point_nat_seq | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Impl.P256.Point.aff_point_seq -> Prims.nat * Prims.nat | {
"end_col": 26,
"end_line": 30,
"start_col": 2,
"start_line": 29
} | |
Prims.GTot | val aff_point_y_as_nat (h: mem) (p: aff_point) : GTot nat | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let aff_point_y_as_nat (h:mem) (p:aff_point) : GTot nat =
as_nat h (gsub p 4ul 4ul) | val aff_point_y_as_nat (h: mem) (p: aff_point) : GTot nat
let aff_point_y_as_nat (h: mem) (p: aff_point) : GTot nat = | false | null | false | as_nat h (gsub p 4ul 4ul) | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.P256.Point.aff_point",
"Hacl.Impl.P256.Bignum.as_nat",
"Lib.Buffer.gsub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Prims.nat"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | false | Hacl.Impl.P256.Point.fsti | {
"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 aff_point_y_as_nat (h: mem) (p: aff_point) : GTot nat | [] | Hacl.Impl.P256.Point.aff_point_y_as_nat | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.P256.Point.aff_point -> Prims.GTot Prims.nat | {
"end_col": 27,
"end_line": 54,
"start_col": 2,
"start_line": 54
} |
Prims.GTot | val point_y_as_nat (h: mem) (e: point) : GTot nat | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let point_y_as_nat (h:mem) (e:point) : GTot nat =
as_nat h (gsub e 4ul 4ul) | val point_y_as_nat (h: mem) (e: point) : GTot nat
let point_y_as_nat (h: mem) (e: point) : GTot nat = | false | null | false | as_nat h (gsub e 4ul 4ul) | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Bignum.as_nat",
"Lib.Buffer.gsub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Prims.nat"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | false | Hacl.Impl.P256.Point.fsti | {
"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 point_y_as_nat (h: mem) (e: point) : GTot nat | [] | Hacl.Impl.P256.Point.point_y_as_nat | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> e: Hacl.Impl.P256.Point.point -> Prims.GTot Prims.nat | {
"end_col": 27,
"end_line": 101,
"start_col": 2,
"start_line": 101
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let as_point_nat_seq (p:point_seq) =
BD.bn_v (LSeq.sub p 0 4),
BD.bn_v (LSeq.sub p 4 4),
BD.bn_v (LSeq.sub p 8 4) | let as_point_nat_seq (p: point_seq) = | false | null | false | BD.bn_v (LSeq.sub p 0 4), BD.bn_v (LSeq.sub p 4 4), BD.bn_v (LSeq.sub p 8 4) | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"total"
] | [
"Hacl.Impl.P256.Point.point_seq",
"FStar.Pervasives.Native.Mktuple3",
"Prims.nat",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.IntTypes.U64",
"Lib.Sequence.sub",
"Lib.IntTypes.uint64",
"FStar.Pervasives.Native.tuple3"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | true | Hacl.Impl.P256.Point.fsti | {
"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 as_point_nat_seq : p: Hacl.Impl.P256.Point.point_seq -> (Prims.nat * Prims.nat) * Prims.nat | [] | Hacl.Impl.P256.Point.as_point_nat_seq | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Impl.P256.Point.point_seq -> (Prims.nat * Prims.nat) * Prims.nat | {
"end_col": 26,
"end_line": 77,
"start_col": 2,
"start_line": 75
} | |
Prims.GTot | val aff_point_x_as_nat (h: mem) (p: aff_point) : GTot nat | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let aff_point_x_as_nat (h:mem) (p:aff_point) : GTot nat =
as_nat h (gsub p 0ul 4ul) | val aff_point_x_as_nat (h: mem) (p: aff_point) : GTot nat
let aff_point_x_as_nat (h: mem) (p: aff_point) : GTot nat = | false | null | false | as_nat h (gsub p 0ul 4ul) | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.P256.Point.aff_point",
"Hacl.Impl.P256.Bignum.as_nat",
"Lib.Buffer.gsub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Prims.nat"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | false | Hacl.Impl.P256.Point.fsti | {
"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 aff_point_x_as_nat (h: mem) (p: aff_point) : GTot nat | [] | Hacl.Impl.P256.Point.aff_point_x_as_nat | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.P256.Point.aff_point -> Prims.GTot Prims.nat | {
"end_col": 27,
"end_line": 50,
"start_col": 2,
"start_line": 50
} |
Prims.GTot | val point_x_as_nat (h: mem) (p: point) : GTot nat | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let point_x_as_nat (h:mem) (p:point) : GTot nat =
as_nat h (gsub p 0ul 4ul) | val point_x_as_nat (h: mem) (p: point) : GTot nat
let point_x_as_nat (h: mem) (p: point) : GTot nat = | false | null | false | as_nat h (gsub p 0ul 4ul) | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Bignum.as_nat",
"Lib.Buffer.gsub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Prims.nat"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | false | Hacl.Impl.P256.Point.fsti | {
"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 point_x_as_nat (h: mem) (p: point) : GTot nat | [] | Hacl.Impl.P256.Point.point_x_as_nat | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.P256.Point.point -> Prims.GTot Prims.nat | {
"end_col": 27,
"end_line": 97,
"start_col": 2,
"start_line": 97
} |
Prims.GTot | val point_z_as_nat (h: mem) (e: point) : GTot nat | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let point_z_as_nat (h:mem) (e:point) : GTot nat =
as_nat h (gsub e 8ul 4ul) | val point_z_as_nat (h: mem) (e: point) : GTot nat
let point_z_as_nat (h: mem) (e: point) : GTot nat = | false | null | false | as_nat h (gsub e 8ul 4ul) | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.P256.Point.point",
"Hacl.Impl.P256.Bignum.as_nat",
"Lib.Buffer.gsub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Prims.nat"
] | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | false | Hacl.Impl.P256.Point.fsti | {
"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 point_z_as_nat (h: mem) (e: point) : GTot nat | [] | Hacl.Impl.P256.Point.point_z_as_nat | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> e: Hacl.Impl.P256.Point.point -> Prims.GTot Prims.nat | {
"end_col": 27,
"end_line": 105,
"start_col": 2,
"start_line": 105
} |
FStar.HyperStack.ST.Stack | val aff_gety (p: aff_point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 4ul 4ul /\ h0 == h1) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let aff_gety (p:aff_point) : Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 4ul 4ul /\ h0 == h1)
= sub p 4ul 4ul | val aff_gety (p: aff_point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 4ul 4ul /\ h0 == h1)
let aff_gety (p: aff_point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 4ul 4ul /\ h0 == h1) = | true | null | false | sub p 4ul 4ul | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [] | [
"Hacl.Impl.P256.Point.aff_point",
"Lib.Buffer.sub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Lib.Buffer.lbuffer_t",
"Hacl.Impl.P256.Bignum.felem",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Prims.l_and",
"Prims.eq2",
"Lib.Buffer.buffer_t",
"Prims.l_or"... | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | false | Hacl.Impl.P256.Point.fsti | {
"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 aff_gety (p: aff_point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 4ul 4ul /\ h0 == h1) | [] | Hacl.Impl.P256.Point.aff_gety | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Impl.P256.Point.aff_point -> FStar.HyperStack.ST.Stack Hacl.Impl.P256.Bignum.felem | {
"end_col": 17,
"end_line": 66,
"start_col": 4,
"start_line": 66
} |
FStar.HyperStack.ST.Stack | val getx (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 4ul /\ h0 == h1) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let getx (p:point) : Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 4ul /\ h0 == h1)
= sub p 0ul 4ul | val getx (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 4ul /\ h0 == h1)
let getx (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 4ul /\ h0 == h1) = | true | null | false | sub p 0ul 4ul | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [] | [
"Hacl.Impl.P256.Point.point",
"Lib.Buffer.sub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Lib.Buffer.lbuffer_t",
"Hacl.Impl.P256.Bignum.felem",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Prims.l_and",
"Prims.eq2",
"Lib.Buffer.buffer_t",
"Prims.l_or",
... | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | false | Hacl.Impl.P256.Point.fsti | {
"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 getx (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 4ul /\ h0 == h1) | [] | Hacl.Impl.P256.Point.getx | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Impl.P256.Point.point -> FStar.HyperStack.ST.Stack Hacl.Impl.P256.Bignum.felem | {
"end_col": 17,
"end_line": 112,
"start_col": 4,
"start_line": 112
} |
FStar.HyperStack.ST.Stack | val getz (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 8ul 4ul /\ h0 == h1) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let getz (p:point) : Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 8ul 4ul /\ h0 == h1)
= sub p 8ul 4ul | val getz (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 8ul 4ul /\ h0 == h1)
let getz (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 8ul 4ul /\ h0 == h1) = | true | null | false | sub p 8ul 4ul | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [] | [
"Hacl.Impl.P256.Point.point",
"Lib.Buffer.sub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Lib.Buffer.lbuffer_t",
"Hacl.Impl.P256.Bignum.felem",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Prims.l_and",
"Prims.eq2",
"Lib.Buffer.buffer_t",
"Prims.l_or",
... | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | false | Hacl.Impl.P256.Point.fsti | {
"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 getz (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 8ul 4ul /\ h0 == h1) | [] | Hacl.Impl.P256.Point.getz | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Impl.P256.Point.point -> FStar.HyperStack.ST.Stack Hacl.Impl.P256.Bignum.felem | {
"end_col": 17,
"end_line": 124,
"start_col": 4,
"start_line": 124
} |
FStar.HyperStack.ST.Stack | val aff_getx (p: aff_point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 4ul /\ h0 == h1) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let aff_getx (p:aff_point) : Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 4ul /\ h0 == h1)
= sub p 0ul 4ul | val aff_getx (p: aff_point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 4ul /\ h0 == h1)
let aff_getx (p: aff_point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 4ul /\ h0 == h1) = | true | null | false | sub p 0ul 4ul | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [] | [
"Hacl.Impl.P256.Point.aff_point",
"Lib.Buffer.sub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Lib.Buffer.lbuffer_t",
"Hacl.Impl.P256.Bignum.felem",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Prims.l_and",
"Prims.eq2",
"Lib.Buffer.buffer_t",
"Prims.l_or"... | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | false | Hacl.Impl.P256.Point.fsti | {
"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 aff_getx (p: aff_point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 0ul 4ul /\ h0 == h1) | [] | Hacl.Impl.P256.Point.aff_getx | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Impl.P256.Point.aff_point -> FStar.HyperStack.ST.Stack Hacl.Impl.P256.Bignum.felem | {
"end_col": 17,
"end_line": 60,
"start_col": 4,
"start_line": 60
} |
FStar.HyperStack.ST.Stack | val gety (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 4ul 4ul /\ h0 == h1) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.Montgomery",
"short_module": "SM"
},
{
"abbrev": tr... | false | let gety (p:point) : Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 4ul 4ul /\ h0 == h1)
= sub p 4ul 4ul | val gety (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 4ul 4ul /\ h0 == h1)
let gety (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 4ul 4ul /\ h0 == h1) = | true | null | false | sub p 4ul 4ul | {
"checked_file": "Hacl.Impl.P256.Point.fsti.checked",
"dependencies": [
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.P256.Montgomery.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked"... | [] | [
"Hacl.Impl.P256.Point.point",
"Lib.Buffer.sub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Lib.Buffer.lbuffer_t",
"Hacl.Impl.P256.Bignum.felem",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Prims.l_and",
"Prims.eq2",
"Lib.Buffer.buffer_t",
"Prims.l_or",
... | [] | module Hacl.Impl.P256.Point
open FStar.Mul
open FStar.HyperStack.All
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.P256.Bignum
module S = Spec.P256
module SM = Hacl.Spec.P256.Montgomery
module BD = Hacl.Spec.Bignum.Definitions
module LSeq = Lib.Sequence
#set-options "--z3rlimit 30 --fuel 0... | false | false | Hacl.Impl.P256.Point.fsti | {
"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 gety (p: point)
: Stack felem
(requires fun h -> live h p)
(ensures fun h0 f h1 -> f == gsub p 4ul 4ul /\ h0 == h1) | [] | Hacl.Impl.P256.Point.gety | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Point.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Hacl.Impl.P256.Point.point -> FStar.HyperStack.ST.Stack Hacl.Impl.P256.Bignum.felem | {
"end_col": 17,
"end_line": 118,
"start_col": 4,
"start_line": 118
} |
Prims.GTot | val withlocal_soundness
(#g:stt_env)
(#t:st_term)
(#c:comp)
(d:st_typing g t c{T_WithLocal? d})
(soundness:soundness_t d)
: GTot (RT.tot_typing (elab_env g)
(elab_st_typing d)
(elab_comp c)) | [
{
"abbrev": true,
"full_module": "Pulse.Steel.Wrapper.Typing",
"short_module": "WT"
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": true,... | false | let withlocal_soundness #g #t #c d soundness =
let T_WithLocal _ init body init_t c x init_typing init_t_typing c_typing body_typing = d in
let CT_ST _ st st_typing = c_typing in
let rg = elab_env g in
let ru = comp_u c in
let ra = elab_term init_t in
let rinit = elab_term init in
let rpre = e... | val withlocal_soundness
(#g:stt_env)
(#t:st_term)
(#c:comp)
(d:st_typing g t c{T_WithLocal? d})
(soundness:soundness_t d)
: GTot (RT.tot_typing (elab_env g)
(elab_st_typing d)
(elab_comp c))
let withlocal_soundness #g #t #c d soundness = | false | null | false | let T_WithLocal _ init body init_t c x init_typing init_t_typing c_typing body_typing = d in
let CT_ST _ st st_typing = c_typing in
let rg = elab_env g in
let ru = comp_u c in
let ra = elab_term init_t in
let rinit = elab_term init in
let rpre = elab_term (comp_pre c) in
let rret_t = elab_term (comp_res c) in
let rpost... | {
"checked_file": "Pulse.Soundness.WithLocal.fst.checked",
"dependencies": [
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Steel.Wrapper.Typing.fsti.checked",
"Pulse.Soundness.Comp.fsti.checked",
"Pulse.Soundness.Common.fst.checked",
"Pulse.Reflection.Util.fst.checked",
... | [
"sometrivial"
] | [
"Pulse.Soundness.Common.stt_env",
"Pulse.Syntax.Base.st_term",
"Pulse.Syntax.Base.comp",
"Pulse.Typing.st_typing",
"Prims.b2t",
"Pulse.Typing.uu___is_T_WithLocal",
"Pulse.Soundness.Common.soundness_t",
"Pulse.Typing.Env.env",
"Pulse.Syntax.Base.term",
"Pulse.Syntax.Base.uu___is_C_ST",
"Pulse.Syn... | [] | module Pulse.Soundness.WithLocal
open Pulse.Syntax
open Pulse.Reflection.Util
open Pulse.Typing
open Pulse.Elaborate.Core
open Pulse.Elaborate
open Pulse.Soundness.Common
module WT = Pulse.Steel.Wrapper.Typing | false | false | Pulse.Soundness.WithLocal.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 8,
"initial_ifuel": 1,
"max_fuel": 8,
"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 withlocal_soundness
(#g:stt_env)
(#t:st_term)
(#c:comp)
(d:st_typing g t c{T_WithLocal? d})
(soundness:soundness_t d)
: GTot (RT.tot_typing (elab_env g)
(elab_st_typing d)
(elab_comp c)) | [] | Pulse.Soundness.WithLocal.withlocal_soundness | {
"file_name": "lib/steel/pulse/Pulse.Soundness.WithLocal.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | d: Pulse.Typing.st_typing g t c {T_WithLocal? d} -> soundness: Pulse.Soundness.Common.soundness_t d
-> Prims.GTot
(FStar.Reflection.Typing.tot_typing (Pulse.Typing.elab_env g)
(Pulse.Elaborate.Core.elab_st_typing d)
(Pulse.Elaborate.Pure.elab_comp c)) | {
"end_col": 16,
"end_line": 53,
"start_col": 46,
"start_line": 13
} |
Prims.Tot | val has_elements (#a: eqtype) (f: a ^-> bool) (xs: list a) : prop | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let has_elements (#a: eqtype) (f: a ^-> bool) (xs: list a): prop =
forall x. f x == x `FLT.mem` xs | val has_elements (#a: eqtype) (f: a ^-> bool) (xs: list a) : prop
let has_elements (#a: eqtype) (f: a ^-> bool) (xs: list a) : prop = | false | null | false | forall x. f x == x `FLT.mem` xs | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"FStar.FunctionalExtensionality.op_Hat_Subtraction_Greater",
"Prims.bool",
"Prims.list",
"Prims.l_Forall",
"Prims.eq2",
"FStar.List.Tot.Base.mem",
"Prims.prop"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 has_elements (#a: eqtype) (f: a ^-> bool) (xs: list a) : prop | [] | FStar.FiniteSet.Base.has_elements | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: a ^-> Prims.bool -> xs: Prims.list a -> Prims.prop | {
"end_col": 33,
"end_line": 43,
"start_col": 2,
"start_line": 43
} |
Prims.GTot | val cardinality (#a: eqtype) (s: set a)
: GTot nat | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let cardinality (#a: eqtype) (s: set a) : GTot nat =
FLT.length (set_as_list s) | val cardinality (#a: eqtype) (s: set a)
: GTot nat
let cardinality (#a: eqtype) (s: set a) : GTot nat = | false | null | false | FLT.length (set_as_list s) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"sometrivial"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"FStar.List.Tot.Base.length",
"FStar.FiniteSet.Base.set_as_list",
"Prims.nat"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 cardinality (#a: eqtype) (s: set a)
: GTot nat | [] | FStar.FiniteSet.Base.cardinality | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: FStar.FiniteSet.Base.set a -> Prims.GTot Prims.nat | {
"end_col": 28,
"end_line": 68,
"start_col": 2,
"start_line": 68
} |
Prims.Tot | val mem (#a: eqtype) (x: a) (s: set a)
: bool | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let mem (#a: eqtype) (x: a) (s: set a) : bool =
s x | val mem (#a: eqtype) (x: a) (s: set a)
: bool
let mem (#a: eqtype) (x: a) (s: set a) : bool = | false | null | false | s x | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"Prims.bool"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 mem (#a: eqtype) (x: a) (s: set a)
: bool | [] | FStar.FiniteSet.Base.mem | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: a -> s: FStar.FiniteSet.Base.set a -> Prims.bool | {
"end_col": 5,
"end_line": 51,
"start_col": 2,
"start_line": 51
} |
Prims.Tot | val subset (#a: eqtype) (s1: set a) (s2: set a)
: Type0 | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let subset (#a: eqtype) (s1: set a) (s2: set a) : Type0 =
forall x. (s1 x = true) ==> (s2 x = true) | val subset (#a: eqtype) (s1: set a) (s2: set a)
: Type0
let subset (#a: eqtype) (s1 s2: set a) : Type0 = | false | null | false | forall x. (s1 x = true) ==> (s2 x = true) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_Equality",
"Prims.bool"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 subset (#a: eqtype) (s1: set a) (s2: set a)
: Type0 | [] | FStar.FiniteSet.Base.subset | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s1: FStar.FiniteSet.Base.set a -> s2: FStar.FiniteSet.Base.set a -> Type0 | {
"end_col": 43,
"end_line": 138,
"start_col": 2,
"start_line": 138
} |
Prims.Tot | val singleton (#a: eqtype) (x: a)
: set a | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let singleton (#a: eqtype) (x: a) : set a =
insert x emptyset | val singleton (#a: eqtype) (x: a)
: set a
let singleton (#a: eqtype) (x: a) : set a = | false | null | false | insert x emptyset | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.insert",
"FStar.FiniteSet.Base.emptyset",
"FStar.FiniteSet.Base.set"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 singleton (#a: eqtype) (x: a)
: set a | [] | FStar.FiniteSet.Base.singleton | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: a -> FStar.FiniteSet.Base.set a | {
"end_col": 19,
"end_line": 93,
"start_col": 2,
"start_line": 93
} |
Prims.Tot | val equal (#a: eqtype) (s1: set a) (s2: set a)
: Type0 | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let equal (#a: eqtype) (s1: set a) (s2: set a) : Type0 =
feq s1 s2 | val equal (#a: eqtype) (s1: set a) (s2: set a)
: Type0
let equal (#a: eqtype) (s1 s2: set a) : Type0 = | false | null | false | feq s1 s2 | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"FStar.FunctionalExtensionality.feq",
"Prims.bool"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 equal (#a: eqtype) (s1: set a) (s2: set a)
: Type0 | [] | FStar.FiniteSet.Base.equal | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s1: FStar.FiniteSet.Base.set a -> s2: FStar.FiniteSet.Base.set a -> Type0 | {
"end_col": 11,
"end_line": 145,
"start_col": 2,
"start_line": 145
} |
Prims.Tot | val union (#a: eqtype) (s1: set a) (s2: set a)
: (set a) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let union (#a: eqtype) (s1: set a) (s2: set a) : (set a) =
intro_set (on_dom a (fun x -> s1 x || s2 x)) (union_lists (set_as_list s1) (set_as_list s2)) | val union (#a: eqtype) (s1: set a) (s2: set a)
: (set a)
let union (#a: eqtype) (s1 s2: set a) : (set a) = | false | null | false | intro_set (on_dom a (fun x -> s1 x || s2 x)) (union_lists (set_as_list s1) (set_as_list s2)) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"FStar.FiniteSet.Base.intro_set",
"FStar.FunctionalExtensionality.on_dom",
"Prims.bool",
"Prims.op_BarBar",
"FStar.Ghost.hide",
"Prims.list",
"FStar.FiniteSet.Base.union_lists",
"FStar.FiniteSet.Base.set_as_list"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 union (#a: eqtype) (s1: set a) (s2: set a)
: (set a) | [] | FStar.FiniteSet.Base.union | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s1: FStar.FiniteSet.Base.set a -> s2: FStar.FiniteSet.Base.set a -> FStar.FiniteSet.Base.set a | {
"end_col": 94,
"end_line": 105,
"start_col": 2,
"start_line": 105
} |
Prims.GTot | val set_as_list (#a: eqtype) (s: set a)
: GTot (xs: list a{list_nonrepeating xs /\ (forall x. FLT.mem x xs = mem x s)}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let set_as_list (#a: eqtype) (s: set a): GTot (xs: list a{list_nonrepeating xs /\ (forall x. FLT.mem x xs = mem x s)}) =
remove_repeats (FStar.IndefiniteDescription.indefinite_description_ghost (list a) (fun xs -> forall x. FLT.mem x xs = mem x s)) | val set_as_list (#a: eqtype) (s: set a)
: GTot (xs: list a{list_nonrepeating xs /\ (forall x. FLT.mem x xs = mem x s)})
let set_as_list (#a: eqtype) (s: set a)
: GTot (xs: list a {list_nonrepeating xs /\ (forall x. FLT.mem x xs = mem x s)}) = | false | null | false | remove_repeats (FStar.IndefiniteDescription.indefinite_description_ghost (list a)
(fun xs -> forall x. FLT.mem x xs = mem x s)) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"sometrivial"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"FStar.FiniteSet.Base.remove_repeats",
"FStar.IndefiniteDescription.indefinite_description_ghost",
"Prims.list",
"Prims.l_Forall",
"Prims.b2t",
"Prims.op_Equality",
"Prims.bool",
"FStar.List.Tot.Base.mem",
"FStar.FiniteSet.Base.mem",
"Prims.prop",
... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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_as_list (#a: eqtype) (s: set a)
: GTot (xs: list a{list_nonrepeating xs /\ (forall x. FLT.mem x xs = mem x s)}) | [] | FStar.FiniteSet.Base.set_as_list | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: FStar.FiniteSet.Base.set a
-> Prims.GTot
(xs:
Prims.list a
{ FStar.FiniteSet.Base.list_nonrepeating xs /\
(forall (x: a). FStar.List.Tot.Base.mem x xs = FStar.FiniteSet.Base.mem x s) }) | {
"end_col": 129,
"end_line": 64,
"start_col": 2,
"start_line": 64
} |
Prims.Tot | val difference (#a: eqtype) (s1: set a) (s2: set a)
: set a | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let difference (#a: eqtype) (s1: set a) (s2: set a) : set a =
intro_set (on_dom a (fun x -> s1 x && not (s2 x))) (difference_lists (set_as_list s1) (set_as_list s2)) | val difference (#a: eqtype) (s1: set a) (s2: set a)
: set a
let difference (#a: eqtype) (s1 s2: set a) : set a = | false | null | false | intro_set (on_dom a (fun x -> s1 x && not (s2 x)))
(difference_lists (set_as_list s1) (set_as_list s2)) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"FStar.FiniteSet.Base.intro_set",
"FStar.FunctionalExtensionality.on_dom",
"Prims.bool",
"Prims.op_AmpAmp",
"Prims.op_Negation",
"FStar.Ghost.hide",
"Prims.list",
"FStar.FiniteSet.Base.difference_lists",
"FStar.FiniteSet.Base.set_as_list"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 difference (#a: eqtype) (s1: set a) (s2: set a)
: set a | [] | FStar.FiniteSet.Base.difference | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s1: FStar.FiniteSet.Base.set a -> s2: FStar.FiniteSet.Base.set a -> FStar.FiniteSet.Base.set a | {
"end_col": 105,
"end_line": 131,
"start_col": 2,
"start_line": 131
} |
Prims.Pure | val intro_set (#a: eqtype) (f: a ^-> bool) (xs: Ghost.erased (list a))
: Pure (set a) (requires f `has_elements` xs) (ensures fun _ -> True) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let intro_set (#a: eqtype) (f: a ^-> bool) (xs: Ghost.erased (list a))
: Pure (set a)
(requires f `has_elements` xs)
(ensures fun _ -> True)
= Classical.exists_intro (fun xs -> f `has_elements` xs) xs;
f | val intro_set (#a: eqtype) (f: a ^-> bool) (xs: Ghost.erased (list a))
: Pure (set a) (requires f `has_elements` xs) (ensures fun _ -> True)
let intro_set (#a: eqtype) (f: a ^-> bool) (xs: Ghost.erased (list a))
: Pure (set a) (requires f `has_elements` xs) (ensures fun _ -> True) = | false | null | false | Classical.exists_intro (fun xs -> f `has_elements` xs) xs;
f | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [] | [
"Prims.eqtype",
"FStar.FunctionalExtensionality.op_Hat_Subtraction_Greater",
"Prims.bool",
"FStar.Ghost.erased",
"Prims.list",
"Prims.unit",
"FStar.Classical.exists_intro",
"FStar.FiniteSet.Base.has_elements",
"FStar.Ghost.reveal",
"FStar.FiniteSet.Base.set",
"Prims.l_True"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 intro_set (#a: eqtype) (f: a ^-> bool) (xs: Ghost.erased (list a))
: Pure (set a) (requires f `has_elements` xs) (ensures fun _ -> True) | [] | FStar.FiniteSet.Base.intro_set | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: a ^-> Prims.bool -> xs: FStar.Ghost.erased (Prims.list a)
-> Prims.Pure (FStar.FiniteSet.Base.set a) | {
"end_col": 3,
"end_line": 75,
"start_col": 2,
"start_line": 74
} |
Prims.Tot | val insert (#a: eqtype) (x: a) (s: set a)
: set a | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let insert (#a: eqtype) (x: a) (s: set a): set a =
intro_set (on_dom _ (fun x' -> x = x' || s x')) (x :: set_as_list s) | val insert (#a: eqtype) (x: a) (s: set a)
: set a
let insert (#a: eqtype) (x: a) (s: set a) : set a = | false | null | false | intro_set (on_dom _ (fun x' -> x = x' || s x')) (x :: set_as_list s) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"FStar.FiniteSet.Base.intro_set",
"FStar.FunctionalExtensionality.on_dom",
"Prims.bool",
"Prims.op_BarBar",
"Prims.op_Equality",
"FStar.Ghost.hide",
"Prims.list",
"Prims.Cons",
"FStar.FiniteSet.Base.set_as_list"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 insert (#a: eqtype) (x: a) (s: set a)
: set a | [] | FStar.FiniteSet.Base.insert | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: a -> s: FStar.FiniteSet.Base.set a -> FStar.FiniteSet.Base.set a | {
"end_col": 70,
"end_line": 86,
"start_col": 2,
"start_line": 86
} |
Prims.GTot | val choose (#a: eqtype) (s: set a{exists x. mem x s})
: GTot (x: a{mem x s}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let choose (#a: eqtype) (s: set a{exists x. mem x s}) : GTot (x: a{mem x s}) =
Cons?.hd (set_as_list s) | val choose (#a: eqtype) (s: set a{exists x. mem x s})
: GTot (x: a{mem x s})
let choose (#a: eqtype) (s: set a {exists x. mem x s}) : GTot (x: a{mem x s}) = | false | null | false | Cons?.hd (set_as_list s) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"sometrivial"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"Prims.l_Exists",
"Prims.b2t",
"FStar.FiniteSet.Base.mem",
"Prims.__proj__Cons__item__hd",
"FStar.FiniteSet.Base.set_as_list"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 choose (#a: eqtype) (s: set a{exists x. mem x s})
: GTot (x: a{mem x s}) | [] | FStar.FiniteSet.Base.choose | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: FStar.FiniteSet.Base.set a {exists (x: a). FStar.FiniteSet.Base.mem x s}
-> Prims.GTot (x: a{FStar.FiniteSet.Base.mem x s}) | {
"end_col": 26,
"end_line": 159,
"start_col": 2,
"start_line": 159
} |
Prims.Tot | val intersection (#a: eqtype) (s1: set a) (s2: set a)
: set a | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let intersection (#a: eqtype) (s1: set a) (s2: set a) : set a =
intro_set (on_dom a (fun x -> s1 x && s2 x)) (intersect_lists (set_as_list s1) (set_as_list s2)) | val intersection (#a: eqtype) (s1: set a) (s2: set a)
: set a
let intersection (#a: eqtype) (s1 s2: set a) : set a = | false | null | false | intro_set (on_dom a (fun x -> s1 x && s2 x)) (intersect_lists (set_as_list s1) (set_as_list s2)) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"FStar.FiniteSet.Base.intro_set",
"FStar.FunctionalExtensionality.on_dom",
"Prims.bool",
"Prims.op_AmpAmp",
"FStar.Ghost.hide",
"Prims.list",
"FStar.FiniteSet.Base.intersect_lists",
"FStar.FiniteSet.Base.set_as_list"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 intersection (#a: eqtype) (s1: set a) (s2: set a)
: set a | [] | FStar.FiniteSet.Base.intersection | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s1: FStar.FiniteSet.Base.set a -> s2: FStar.FiniteSet.Base.set a -> FStar.FiniteSet.Base.set a | {
"end_col": 98,
"end_line": 118,
"start_col": 2,
"start_line": 118
} |
Prims.Tot | val remove_repeats (#a: eqtype) (xs: list a)
: (ys: list a {list_nonrepeating ys /\ (forall y. FLT.mem y ys <==> FLT.mem y xs)}) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let rec remove_repeats (#a: eqtype) (xs: list a)
: (ys: list a{list_nonrepeating ys /\ (forall y. FLT.mem y ys <==> FLT.mem y xs)}) =
match xs with
| [] -> []
| hd :: tl -> let tl' = remove_repeats tl in if FLT.mem hd tl then tl' else hd :: tl' | val remove_repeats (#a: eqtype) (xs: list a)
: (ys: list a {list_nonrepeating ys /\ (forall y. FLT.mem y ys <==> FLT.mem y xs)})
let rec remove_repeats (#a: eqtype) (xs: list a)
: (ys: list a {list_nonrepeating ys /\ (forall y. FLT.mem y ys <==> FLT.mem y xs)}) = | false | null | false | match xs with
| [] -> []
| hd :: tl ->
let tl' = remove_repeats tl in
if FLT.mem hd tl then tl' else hd :: tl' | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"Prims.list",
"Prims.Nil",
"FStar.List.Tot.Base.mem",
"Prims.bool",
"Prims.Cons",
"Prims.l_and",
"Prims.b2t",
"FStar.FiniteSet.Base.list_nonrepeating",
"Prims.l_Forall",
"Prims.l_iff",
"FStar.FiniteSet.Base.remove_repeats"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 remove_repeats (#a: eqtype) (xs: list a)
: (ys: list a {list_nonrepeating ys /\ (forall y. FLT.mem y ys <==> FLT.mem y xs)}) | [
"recursion"
] | FStar.FiniteSet.Base.remove_repeats | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | xs: Prims.list a
-> ys:
Prims.list a
{ FStar.FiniteSet.Base.list_nonrepeating ys /\
(forall (y: a). FStar.List.Tot.Base.mem y ys <==> FStar.List.Tot.Base.mem y xs) } | {
"end_col": 87,
"end_line": 61,
"start_col": 2,
"start_line": 59
} |
Prims.Tot | val disjoint (#a: eqtype) (s1: set a) (s2: set a)
: Type0 | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let disjoint (#a: eqtype) (s1: set a) (s2: set a) : Type0 =
forall x. not (s1 x && s2 x) | val disjoint (#a: eqtype) (s1: set a) (s2: set a)
: Type0
let disjoint (#a: eqtype) (s1 s2: set a) : Type0 = | false | null | false | forall x. not (s1 x && s2 x) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"Prims.l_Forall",
"Prims.b2t",
"Prims.op_Negation",
"Prims.op_AmpAmp"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 disjoint (#a: eqtype) (s1: set a) (s2: set a)
: Type0 | [] | FStar.FiniteSet.Base.disjoint | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s1: FStar.FiniteSet.Base.set a -> s2: FStar.FiniteSet.Base.set a -> Type0 | {
"end_col": 30,
"end_line": 152,
"start_col": 2,
"start_line": 152
} |
Prims.Tot | val intersect_lists (#a: eqtype) (xs ys: list a)
: (zs: list a {forall z. FLT.mem z zs <==> FLT.mem z xs /\ FLT.mem z ys}) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let rec intersect_lists (#a: eqtype) (xs: list a) (ys: list a)
: (zs: list a{forall z. FLT.mem z zs <==> FLT.mem z xs /\ FLT.mem z ys}) =
match xs with
| [] -> []
| hd :: tl -> let zs' = intersect_lists tl ys in if FLT.mem hd ys then hd :: zs' else zs' | val intersect_lists (#a: eqtype) (xs ys: list a)
: (zs: list a {forall z. FLT.mem z zs <==> FLT.mem z xs /\ FLT.mem z ys})
let rec intersect_lists (#a: eqtype) (xs ys: list a)
: (zs: list a {forall z. FLT.mem z zs <==> FLT.mem z xs /\ FLT.mem z ys}) = | false | null | false | match xs with
| [] -> []
| hd :: tl ->
let zs' = intersect_lists tl ys in
if FLT.mem hd ys then hd :: zs' else zs' | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"Prims.list",
"Prims.Nil",
"FStar.List.Tot.Base.mem",
"Prims.Cons",
"Prims.bool",
"Prims.l_Forall",
"Prims.l_iff",
"Prims.b2t",
"Prims.l_and",
"FStar.FiniteSet.Base.intersect_lists"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 intersect_lists (#a: eqtype) (xs ys: list a)
: (zs: list a {forall z. FLT.mem z zs <==> FLT.mem z xs /\ FLT.mem z ys}) | [
"recursion"
] | FStar.FiniteSet.Base.intersect_lists | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | xs: Prims.list a -> ys: Prims.list a
-> zs:
Prims.list a
{ forall (z: a).
FStar.List.Tot.Base.mem z zs <==>
FStar.List.Tot.Base.mem z xs /\ FStar.List.Tot.Base.mem z ys } | {
"end_col": 91,
"end_line": 115,
"start_col": 2,
"start_line": 113
} |
Prims.Tot | val emptyset (#a: eqtype)
: set a | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let emptyset (#a: eqtype): set a = intro_set (on_dom a (fun _ -> false)) [] | val emptyset (#a: eqtype)
: set a
let emptyset (#a: eqtype) : set a = | false | null | false | intro_set (on_dom a (fun _ -> false)) [] | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.intro_set",
"FStar.FunctionalExtensionality.on_dom",
"Prims.bool",
"FStar.Ghost.hide",
"Prims.list",
"Prims.Nil",
"FStar.FiniteSet.Base.set"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 emptyset (#a: eqtype)
: set a | [] | FStar.FiniteSet.Base.emptyset | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | FStar.FiniteSet.Base.set a | {
"end_col": 75,
"end_line": 79,
"start_col": 35,
"start_line": 79
} |
FStar.Pervasives.Lemma | val intersection_cardinality_lemma: Prims.unit -> Lemma (intersection_cardinality_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let intersection_cardinality_lemma ()
: Lemma (intersection_cardinality_fact) =
introduce forall (a: eqtype) (s1: set a) (s2: set a).
cardinality (union s1 s2) + cardinality (intersection s1 s2) = cardinality s1 + cardinality s2
with
intersection_cardinality_helper a s1 s2 | val intersection_cardinality_lemma: Prims.unit -> Lemma (intersection_cardinality_fact)
let intersection_cardinality_lemma () : Lemma (intersection_cardinality_fact) = | false | null | true | introduce forall (a: eqtype) (s1: set a) (s2: set a) . cardinality (union s1 s2) +
cardinality (intersection s1 s2) =
cardinality s1 + cardinality s2
with intersection_cardinality_helper a s1 s2 | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Addition",
"FStar.FiniteSet.Base.cardinality",
"FStar.FiniteSet.Base.union",
"FStar.FiniteSet.Base.intersection",
"FStar.... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 intersection_cardinality_lemma: Prims.unit -> Lemma (intersection_cardinality_fact) | [] | FStar.FiniteSet.Base.intersection_cardinality_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.intersection_cardinality_fact) | {
"end_col": 43,
"end_line": 345,
"start_col": 2,
"start_line": 342
} |
FStar.Pervasives.Lemma | val remove_insert_lemma: Prims.unit -> Lemma (remove_insert_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let remove_insert_lemma ()
: Lemma (remove_insert_fact) =
introduce forall (a: eqtype) (x: a) (s: set a). mem x s = false ==> remove x (insert x s) == s
with introduce mem x s = false ==> remove x (insert x s) == s
with _. remove_insert_helper a x s | val remove_insert_lemma: Prims.unit -> Lemma (remove_insert_fact)
let remove_insert_lemma () : Lemma (remove_insert_fact) = | false | null | true | introduce forall (a: eqtype) (x: a) (s: set a) . mem x s = false ==> remove x (insert x s) == s
with introduce mem x s = false ==> remove x (insert x s) == s
with _. remove_insert_helper a x s | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_Equality",
"Prims.bool",
"FStar.FiniteSet.Base.mem",
"Prims.eq2",
"FStar.FiniteSet.Base.remove",
"FStar.FiniteSet.Base.insert",
"FStar.Cla... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 remove_insert_lemma: Prims.unit -> Lemma (remove_insert_fact) | [] | FStar.FiniteSet.Base.remove_insert_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.remove_insert_fact) | {
"end_col": 36,
"end_line": 431,
"start_col": 2,
"start_line": 429
} |
FStar.Pervasives.Lemma | val subset_lemma: Prims.unit -> Lemma (subset_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let subset_lemma ()
: Lemma (subset_fact) =
introduce forall (a: eqtype) (s1: set a) (s2: set a). subset s1 s2 <==> (forall o.{:pattern mem o s1 \/ mem o s2} mem o s1 ==> mem o s2)
with subset_helper a s1 s2 | val subset_lemma: Prims.unit -> Lemma (subset_fact)
let subset_lemma () : Lemma (subset_fact) = | false | null | true | introduce forall (a: eqtype) (s1: set a) (s2: set a) . subset s1 s2 <==>
(forall o. {:pattern mem o s1\/mem o s2} mem o s1 ==> mem o s2)
with subset_helper a s1 s2 | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.l_iff",
"FStar.FiniteSet.Base.subset",
"Prims.l_imp",
"Prims.b2t",
"FStar.FiniteSet.Base.mem",
"FStar.FiniteSet.Base.subset_helper",
"Prims.squash",
"Prims.l_True",
"FSt... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 subset_lemma: Prims.unit -> Lemma (subset_fact) | [] | FStar.FiniteSet.Base.subset_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.subset_fact) | {
"end_col": 28,
"end_line": 381,
"start_col": 2,
"start_line": 380
} |
FStar.Pervasives.Lemma | val difference_cardinality_lemma: Prims.unit -> Lemma (difference_cardinality_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let difference_cardinality_lemma ()
: Lemma (difference_cardinality_fact) =
introduce forall (a: eqtype) (s1: set a) (s2: set a).
cardinality (difference s1 s2) + cardinality (difference s2 s1) +
cardinality (intersection s1 s2) = cardinality (union s1 s2)
/\ cardina... | val difference_cardinality_lemma: Prims.unit -> Lemma (difference_cardinality_fact)
let difference_cardinality_lemma () : Lemma (difference_cardinality_fact) = | false | null | true | introduce forall (a: eqtype) (s1: set a) (s2: set a) . cardinality (difference s1 s2) +
cardinality (difference s2 s1) +
cardinality (intersection s1 s2) =
cardinality (union s1 s2) /\
cardinality (difference s1 s2) = cardinality s1 - cardinality (intersection s1 s2)
with difference_cardinality_helper a s1 s2 | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Addition",
"FStar.FiniteSet.Base.cardinality",
"FStar.FiniteSet.Base.difference",
"FStar.FiniteSet.Base.in... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 difference_cardinality_lemma: Prims.unit -> Lemma (difference_cardinality_fact) | [] | FStar.FiniteSet.Base.difference_cardinality_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.difference_cardinality_fact) | {
"end_col": 41,
"end_line": 369,
"start_col": 2,
"start_line": 364
} |
FStar.Pervasives.Lemma | val all_finite_set_facts_lemma : unit -> Lemma (all_finite_set_facts) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.FiniteSet",
"short_module": null
},
{
"abbrev": false,
... | false | let all_finite_set_facts_lemma () : Lemma (all_finite_set_facts) =
empty_set_contains_no_elements_lemma ();
length_zero_lemma ();
singleton_contains_argument_lemma ();
singleton_contains_lemma ();
singleton_cardinality_lemma ();
insert_lemma ();
insert_contains_argument_lemma ();
insert_contains_lemma (... | val all_finite_set_facts_lemma : unit -> Lemma (all_finite_set_facts)
let all_finite_set_facts_lemma () : Lemma (all_finite_set_facts) = | false | null | true | empty_set_contains_no_elements_lemma ();
length_zero_lemma ();
singleton_contains_argument_lemma ();
singleton_contains_lemma ();
singleton_cardinality_lemma ();
insert_lemma ();
insert_contains_argument_lemma ();
insert_contains_lemma ();
insert_member_cardinality_lemma ();
insert_nonmember_cardinality_lemma ();
union... | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.FiniteSet.Base.set_as_list_cardinality_lemma",
"FStar.FiniteSet.Base.remove_insert_lemma",
"FStar.FiniteSet.Base.insert_remove_lemma",
"FStar.FiniteSet.Base.disjoint_lemma",
"FStar.FiniteSet.Base.equal_extensionality_lemma",
"FStar.FiniteSet.Base.equal_lemma",
"FStar.FiniteSet.Bas... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 all_finite_set_facts_lemma : unit -> Lemma (all_finite_set_facts) | [] | FStar.FiniteSet.Base.all_finite_set_facts_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.all_finite_set_facts) | {
"end_col": 34,
"end_line": 468,
"start_col": 2,
"start_line": 439
} |
FStar.Pervasives.Lemma | val insert_member_cardinality_lemma: Prims.unit -> Lemma (insert_member_cardinality_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let insert_member_cardinality_lemma ()
: Lemma (insert_member_cardinality_fact) =
introduce forall (a: eqtype) (s: set a) (x: a). mem x s ==> cardinality (insert x s) = cardinality s
with
introduce mem x s ==> cardinality (insert x s) = cardinality s
with _. (
reveal_opaque (`%cardinality) (cardinalit... | val insert_member_cardinality_lemma: Prims.unit -> Lemma (insert_member_cardinality_fact)
let insert_member_cardinality_lemma () : Lemma (insert_member_cardinality_fact) = | false | null | true | introduce forall (a: eqtype) (s: set a) (x: a) . mem x s ==>
cardinality (insert x s) = cardinality s
with introduce mem x s ==> cardinality (insert x s) = cardinality s
with _. (reveal_opaque (`%cardinality) (cardinality #a);
nonrepeating_lists_with_same_elements_have_same_length (set_as_list s) (set_as_list (insert... | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.l_imp",
"Prims.b2t",
"FStar.FiniteSet.Base.mem",
"Prims.op_Equality",
"Prims.nat",
"FStar.FiniteSet.Base.cardinality",
"FStar.FiniteSet.Base.insert",
"FStar.Classical.Suga... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 insert_member_cardinality_lemma: Prims.unit -> Lemma (insert_member_cardinality_fact) | [] | FStar.FiniteSet.Base.insert_member_cardinality_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit
-> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.insert_member_cardinality_fact) | {
"end_col": 5,
"end_line": 242,
"start_col": 2,
"start_line": 236
} |
FStar.Pervasives.Lemma | val union_of_disjoint_sets_cardinality_lemma (#a: eqtype) (s1 s2: set a)
: Lemma (requires disjoint s1 s2)
(ensures cardinality (union s1 s2) = cardinality s1 + cardinality s2) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let union_of_disjoint_sets_cardinality_lemma (#a: eqtype) (s1: set a) (s2: set a)
: Lemma (requires disjoint s1 s2)
(ensures cardinality (union s1 s2) = cardinality s1 + cardinality s2) =
reveal_opaque (`%cardinality) (cardinality #a);
union_of_disjoint_nonrepeating_lists_length_lemma (set_as_list s1) (set... | val union_of_disjoint_sets_cardinality_lemma (#a: eqtype) (s1 s2: set a)
: Lemma (requires disjoint s1 s2)
(ensures cardinality (union s1 s2) = cardinality s1 + cardinality s2)
let union_of_disjoint_sets_cardinality_lemma (#a: eqtype) (s1 s2: set a)
: Lemma (requires disjoint s1 s2)
(ensures cardina... | false | null | true | reveal_opaque (`%cardinality) (cardinality #a);
union_of_disjoint_nonrepeating_lists_length_lemma (set_as_list s1)
(set_as_list s2)
(set_as_list (union s1 s2)) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"FStar.FiniteSet.Base.union_of_disjoint_nonrepeating_lists_length_lemma",
"FStar.FiniteSet.Base.set_as_list",
"FStar.FiniteSet.Base.union",
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"Prims.nat",
"FStar.FiniteSet.Base.cardinality",
"FStar.FiniteSet.... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 union_of_disjoint_sets_cardinality_lemma (#a: eqtype) (s1 s2: set a)
: Lemma (requires disjoint s1 s2)
(ensures cardinality (union s1 s2) = cardinality s1 + cardinality s2) | [] | FStar.FiniteSet.Base.union_of_disjoint_sets_cardinality_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s1: FStar.FiniteSet.Base.set a -> s2: FStar.FiniteSet.Base.set a
-> FStar.Pervasives.Lemma (requires FStar.FiniteSet.Base.disjoint s1 s2)
(ensures
FStar.FiniteSet.Base.cardinality (FStar.FiniteSet.Base.union s1 s2) =
FStar.FiniteSet.Base.cardinality s1 + FStar.FiniteSet.Base.cardinality s2) | {
"end_col": 113,
"end_line": 315,
"start_col": 2,
"start_line": 314
} |
Prims.Tot | val remove_from_nonrepeating_list
(#a: eqtype)
(x: a)
(xs: list a {FLT.mem x xs /\ list_nonrepeating xs})
: (xs':
list a
{ list_nonrepeating xs' /\ FLT.length xs' = FLT.length xs - 1 /\
(forall y. FLT.mem y xs' <==> FLT.mem y xs /\ y <> x) }) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let rec remove_from_nonrepeating_list (#a: eqtype) (x: a) (xs: list a{FLT.mem x xs /\ list_nonrepeating xs})
: (xs': list a{ list_nonrepeating xs'
/\ FLT.length xs' = FLT.length xs - 1
/\ (forall y. FLT.mem y xs' <==> FLT.mem y xs /\ y <> x)}) =
match xs with
| hd :: tl -> if x = hd t... | val remove_from_nonrepeating_list
(#a: eqtype)
(x: a)
(xs: list a {FLT.mem x xs /\ list_nonrepeating xs})
: (xs':
list a
{ list_nonrepeating xs' /\ FLT.length xs' = FLT.length xs - 1 /\
(forall y. FLT.mem y xs' <==> FLT.mem y xs /\ y <> x) })
let rec remove_from_nonrepeatin... | false | null | false | match xs with | hd :: tl -> if x = hd then tl else hd :: (remove_from_nonrepeating_list x tl) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"Prims.list",
"Prims.l_and",
"Prims.b2t",
"FStar.List.Tot.Base.mem",
"FStar.FiniteSet.Base.list_nonrepeating",
"Prims.op_Equality",
"Prims.bool",
"Prims.Cons",
"FStar.FiniteSet.Base.remove_from_nonrepeating_list",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.op_Subtracti... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 remove_from_nonrepeating_list
(#a: eqtype)
(x: a)
(xs: list a {FLT.mem x xs /\ list_nonrepeating xs})
: (xs':
list a
{ list_nonrepeating xs' /\ FLT.length xs' = FLT.length xs - 1 /\
(forall y. FLT.mem y xs' <==> FLT.mem y xs /\ y <> x) }) | [
"recursion"
] | FStar.FiniteSet.Base.remove_from_nonrepeating_list | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: a -> xs: Prims.list a {FStar.List.Tot.Base.mem x xs /\ FStar.FiniteSet.Base.list_nonrepeating xs}
-> xs':
Prims.list a
{ FStar.FiniteSet.Base.list_nonrepeating xs' /\
FStar.List.Tot.Base.length xs' = FStar.List.Tot.Base.length xs - 1 /\
(forall (y: a). FStar.List.Tot.Base.mem y xs' <==> F... | {
"end_col": 81,
"end_line": 225,
"start_col": 2,
"start_line": 224
} |
FStar.Pervasives.Lemma | val union_of_three_disjoint_sets_cardinality_lemma (#a: eqtype) (s1 s2 s3: set a)
: Lemma (requires disjoint s1 s2 /\ disjoint s2 s3 /\ disjoint s1 s3)
(ensures
cardinality (union (union s1 s2) s3) = cardinality s1 + cardinality s2 + cardinality s3) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let union_of_three_disjoint_sets_cardinality_lemma (#a: eqtype) (s1: set a) (s2: set a) (s3: set a)
: Lemma (requires disjoint s1 s2 /\ disjoint s2 s3 /\ disjoint s1 s3)
(ensures cardinality (union (union s1 s2) s3) = cardinality s1 + cardinality s2 + cardinality s3) =
union_of_disjoint_sets_cardinality_lemm... | val union_of_three_disjoint_sets_cardinality_lemma (#a: eqtype) (s1 s2 s3: set a)
: Lemma (requires disjoint s1 s2 /\ disjoint s2 s3 /\ disjoint s1 s3)
(ensures
cardinality (union (union s1 s2) s3) = cardinality s1 + cardinality s2 + cardinality s3)
let union_of_three_disjoint_sets_cardinality_lemma (... | false | null | true | union_of_disjoint_sets_cardinality_lemma s1 s2;
union_of_disjoint_sets_cardinality_lemma (union s1 s2) s3 | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"FStar.FiniteSet.Base.union_of_disjoint_sets_cardinality_lemma",
"FStar.FiniteSet.Base.union",
"Prims.unit",
"Prims.l_and",
"FStar.FiniteSet.Base.disjoint",
"Prims.squash",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.FiniteSet.Base.cardinal... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 union_of_three_disjoint_sets_cardinality_lemma (#a: eqtype) (s1 s2 s3: set a)
: Lemma (requires disjoint s1 s2 /\ disjoint s2 s3 /\ disjoint s1 s3)
(ensures
cardinality (union (union s1 s2) s3) = cardinality s1 + cardinality s2 + cardinality s3) | [] | FStar.FiniteSet.Base.union_of_three_disjoint_sets_cardinality_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s1: FStar.FiniteSet.Base.set a -> s2: FStar.FiniteSet.Base.set a -> s3: FStar.FiniteSet.Base.set a
-> FStar.Pervasives.Lemma
(requires
FStar.FiniteSet.Base.disjoint s1 s2 /\ FStar.FiniteSet.Base.disjoint s2 s3 /\
FStar.FiniteSet.Base.disjoint s1 s3)
(ensures
FStar.FiniteSet.Base.ca... | {
"end_col": 59,
"end_line": 321,
"start_col": 2,
"start_line": 320
} |
FStar.Pervasives.Lemma | val subset_helper (a: eqtype) (s1 s2: set a)
: Lemma (subset s1 s2 <==> (forall o. {:pattern mem o s1\/mem o s2} mem o s1 ==> mem o s2)) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let subset_helper (a: eqtype) (s1: set a) (s2: set a)
: Lemma (subset s1 s2 <==> (forall o.{:pattern mem o s1 \/ mem o s2} mem o s1 ==> mem o s2)) =
introduce (forall o.{:pattern mem o s1 \/ mem o s2} mem o s1 ==> mem o s2) ==> subset s1 s2
with _.
introduce forall x. s1 x = true ==> s2 x = true
with asser... | val subset_helper (a: eqtype) (s1 s2: set a)
: Lemma (subset s1 s2 <==> (forall o. {:pattern mem o s1\/mem o s2} mem o s1 ==> mem o s2))
let subset_helper (a: eqtype) (s1 s2: set a)
: Lemma (subset s1 s2 <==> (forall o. {:pattern mem o s1\/mem o s2} mem o s1 ==> mem o s2)) = | false | null | true | introduce (forall o. {:pattern mem o s1\/mem o s2} mem o s1 ==> mem o s2) ==> subset s1 s2
with _. introduce forall x . s1 x = true ==> s2 x = true
with assert (mem x s1 = s1 x) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"FStar.Classical.Sugar.implies_intro",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.b2t",
"FStar.FiniteSet.Base.mem",
"Prims.squash",
"FStar.FiniteSet.Base.subset",
"FStar.Classical.Sugar.forall_intro",
"Prims.op_Equality",
"Prims.bool",
"Prims._assert"... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 subset_helper (a: eqtype) (s1 s2: set a)
: Lemma (subset s1 s2 <==> (forall o. {:pattern mem o s1\/mem o s2} mem o s1 ==> mem o s2)) | [] | FStar.FiniteSet.Base.subset_helper | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: Prims.eqtype -> s1: FStar.FiniteSet.Base.set a -> s2: FStar.FiniteSet.Base.set a
-> FStar.Pervasives.Lemma
(ensures
FStar.FiniteSet.Base.subset s1 s2 <==>
(forall (o: a). {:pattern FStar.FiniteSet.Base.mem o s1\/FStar.FiniteSet.Base.mem o s2}
FStar.FiniteSet.Base.mem o s1 ==> FStar.Finite... | {
"end_col": 33,
"end_line": 376,
"start_col": 2,
"start_line": 373
} |
Prims.Tot | val difference_lists (#a: eqtype) (xs ys: list a)
: (zs: list a {forall z. FLT.mem z zs <==> FLT.mem z xs /\ ~(FLT.mem z ys)}) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let rec difference_lists (#a: eqtype) (xs: list a) (ys: list a)
: (zs: list a{forall z. FLT.mem z zs <==> FLT.mem z xs /\ ~(FLT.mem z ys)}) =
match xs with
| [] -> []
| hd :: tl -> let zs' = difference_lists tl ys in if FLT.mem hd ys then zs' else hd :: zs' | val difference_lists (#a: eqtype) (xs ys: list a)
: (zs: list a {forall z. FLT.mem z zs <==> FLT.mem z xs /\ ~(FLT.mem z ys)})
let rec difference_lists (#a: eqtype) (xs ys: list a)
: (zs: list a {forall z. FLT.mem z zs <==> FLT.mem z xs /\ ~(FLT.mem z ys)}) = | false | null | false | match xs with
| [] -> []
| hd :: tl ->
let zs' = difference_lists tl ys in
if FLT.mem hd ys then zs' else hd :: zs' | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"Prims.list",
"Prims.Nil",
"FStar.List.Tot.Base.mem",
"Prims.bool",
"Prims.Cons",
"Prims.l_Forall",
"Prims.l_iff",
"Prims.b2t",
"Prims.l_and",
"Prims.l_not",
"FStar.FiniteSet.Base.difference_lists"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 difference_lists (#a: eqtype) (xs ys: list a)
: (zs: list a {forall z. FLT.mem z zs <==> FLT.mem z xs /\ ~(FLT.mem z ys)}) | [
"recursion"
] | FStar.FiniteSet.Base.difference_lists | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | xs: Prims.list a -> ys: Prims.list a
-> zs:
Prims.list a
{ forall (z: a).
FStar.List.Tot.Base.mem z zs <==>
FStar.List.Tot.Base.mem z xs /\ ~(FStar.List.Tot.Base.mem z ys) } | {
"end_col": 92,
"end_line": 128,
"start_col": 2,
"start_line": 126
} |
FStar.Pervasives.Lemma | val equal_lemma: Prims.unit -> Lemma (equal_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let equal_lemma ()
: Lemma (equal_fact) =
introduce forall (a: eqtype) (s1: set a) (s2: set a).
equal s1 s2 <==> (forall o.{:pattern mem o s1 \/ mem o s2} mem o s1 <==> mem o s2)
with (
introduce (forall o.{:pattern mem o s1 \/ mem o s2} mem o s1 <==> mem o s2) ==> equal s1 s2
with _.
introduce fo... | val equal_lemma: Prims.unit -> Lemma (equal_fact)
let equal_lemma () : Lemma (equal_fact) = | false | null | true | introduce forall (a: eqtype) (s1: set a) (s2: set a) . equal s1 s2 <==>
(forall o. {:pattern mem o s1\/mem o s2} mem o s1 <==> mem o s2)
with (introduce (forall o. {:pattern mem o s1\/mem o s2} mem o s1 <==> mem o s2) ==> equal s1 s2
with _. introduce forall x . s1 x = true <==> s2 x = true
with assert (mem x s1 = ... | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.l_iff",
"FStar.FiniteSet.Base.equal",
"Prims.b2t",
"FStar.FiniteSet.Base.mem",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"Prims.op_Equality",
"Prims.bool",
... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 equal_lemma: Prims.unit -> Lemma (equal_fact) | [] | FStar.FiniteSet.Base.equal_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.equal_fact) | {
"end_col": 3,
"end_line": 392,
"start_col": 2,
"start_line": 385
} |
FStar.Pervasives.Lemma | val singleton_cardinality_helper (#a: eqtype) (r: a) (xs: list a)
: Lemma (requires FLT.mem r xs /\ (forall x. FLT.mem x xs <==> x = r))
(ensures remove_repeats xs == [r]) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let rec singleton_cardinality_helper (#a: eqtype) (r: a) (xs: list a)
: Lemma (requires FLT.mem r xs /\ (forall x. FLT.mem x xs <==> x = r))
(ensures remove_repeats xs == [r]) =
match xs with
| [x] -> ()
| hd :: tl ->
assert (Cons?.hd tl = r);
singleton_cardinality_helper r tl | val singleton_cardinality_helper (#a: eqtype) (r: a) (xs: list a)
: Lemma (requires FLT.mem r xs /\ (forall x. FLT.mem x xs <==> x = r))
(ensures remove_repeats xs == [r])
let rec singleton_cardinality_helper (#a: eqtype) (r: a) (xs: list a)
: Lemma (requires FLT.mem r xs /\ (forall x. FLT.mem x xs <==> x... | false | null | true | match xs with
| [x] -> ()
| hd :: tl ->
assert (Cons?.hd tl = r);
singleton_cardinality_helper r tl | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.eqtype",
"Prims.list",
"FStar.FiniteSet.Base.singleton_cardinality_helper",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"Prims.__proj__Cons__item__hd",
"Prims.l_and",
"FStar.List.Tot.Base.mem",
"Prims.l_Forall",
"Prims.l_iff",
"Prims.squash",
"Prims.eq2",
"FSt... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 singleton_cardinality_helper (#a: eqtype) (r: a) (xs: list a)
: Lemma (requires FLT.mem r xs /\ (forall x. FLT.mem x xs <==> x = r))
(ensures remove_repeats xs == [r]) | [
"recursion"
] | FStar.FiniteSet.Base.singleton_cardinality_helper | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | r: a -> xs: Prims.list a
-> FStar.Pervasives.Lemma
(requires
FStar.List.Tot.Base.mem r xs /\ (forall (x: a). FStar.List.Tot.Base.mem x xs <==> x = r))
(ensures FStar.FiniteSet.Base.remove_repeats xs == [r]) | {
"end_col": 39,
"end_line": 198,
"start_col": 2,
"start_line": 194
} |
Prims.Tot | val union_lists (#a: eqtype) (xs ys: list a)
: (zs: list a {forall z. FLT.mem z zs <==> FLT.mem z xs \/ FLT.mem z ys}) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let rec union_lists (#a: eqtype) (xs: list a) (ys: list a) : (zs: list a{forall z. FLT.mem z zs <==> FLT.mem z xs \/ FLT.mem z ys}) =
match xs with
| [] -> ys
| hd :: tl -> hd :: union_lists tl ys | val union_lists (#a: eqtype) (xs ys: list a)
: (zs: list a {forall z. FLT.mem z zs <==> FLT.mem z xs \/ FLT.mem z ys})
let rec union_lists (#a: eqtype) (xs ys: list a)
: (zs: list a {forall z. FLT.mem z zs <==> FLT.mem z xs \/ FLT.mem z ys}) = | false | null | false | match xs with
| [] -> ys
| hd :: tl -> hd :: union_lists tl ys | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"total"
] | [
"Prims.eqtype",
"Prims.list",
"Prims.Cons",
"FStar.FiniteSet.Base.union_lists",
"Prims.l_Forall",
"Prims.l_iff",
"Prims.b2t",
"FStar.List.Tot.Base.mem",
"Prims.l_or"
] | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 union_lists (#a: eqtype) (xs ys: list a)
: (zs: list a {forall z. FLT.mem z zs <==> FLT.mem z xs \/ FLT.mem z ys}) | [
"recursion"
] | FStar.FiniteSet.Base.union_lists | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | xs: Prims.list a -> ys: Prims.list a
-> zs:
Prims.list a
{ forall (z: a).
FStar.List.Tot.Base.mem z zs <==>
FStar.List.Tot.Base.mem z xs \/ FStar.List.Tot.Base.mem z ys } | {
"end_col": 39,
"end_line": 102,
"start_col": 2,
"start_line": 100
} |
FStar.Pervasives.Lemma | val disjoint_lemma: Prims.unit -> Lemma (disjoint_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let disjoint_lemma ()
: Lemma (disjoint_fact) =
introduce forall (a: eqtype) (s1: set a) (s2: set a).
disjoint s1 s2 <==> (forall o.{:pattern mem o s1 \/ mem o s2} not (mem o s1) \/ not (mem o s2))
with (
introduce (forall o.{:pattern mem o s1 \/ mem o s2} not (mem o s1) \/ not (mem o s2)) ==> disjoint s1 s... | val disjoint_lemma: Prims.unit -> Lemma (disjoint_fact)
let disjoint_lemma () : Lemma (disjoint_fact) = | false | null | true | introduce forall (a: eqtype) (s1: set a) (s2: set a) . disjoint s1 s2 <==>
(forall o. {:pattern mem o s1\/mem o s2} not (mem o s1) \/ not (mem o s2))
with (introduce (forall o. {:pattern mem o s1\/mem o s2} not (mem o s1) \/ not (mem o s2)) ==> disjoint
s1
s2
with _. (introduce forall x . not (s1 x && s2 x)
... | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.l_iff",
"FStar.FiniteSet.Base.disjoint",
"Prims.l_or",
"Prims.b2t",
"Prims.op_Negation",
"FStar.FiniteSet.Base.mem",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 disjoint_lemma: Prims.unit -> Lemma (disjoint_fact) | [] | FStar.FiniteSet.Base.disjoint_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.disjoint_fact) | {
"end_col": 3,
"end_line": 408,
"start_col": 2,
"start_line": 400
} |
FStar.Pervasives.Lemma | val length_zero_lemma: Prims.unit -> Lemma (length_zero_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let length_zero_lemma ()
: Lemma (length_zero_fact) =
introduce forall (a: eqtype) (s: set a). (cardinality s = 0 <==> s == emptyset) /\ (cardinality s <> 0 <==> (exists x. mem x s))
with (
reveal_opaque (`%cardinality) (cardinality #a);
introduce cardinality s = 0 ==> s == emptyset
with _. assert (feq ... | val length_zero_lemma: Prims.unit -> Lemma (length_zero_fact)
let length_zero_lemma () : Lemma (length_zero_fact) = | false | null | true | introduce forall (a: eqtype) (s: set a) . (cardinality s = 0 <==> s == emptyset) /\
(cardinality s <> 0 <==> (exists x. mem x s))
with (reveal_opaque (`%cardinality) (cardinality #a);
introduce cardinality s = 0 ==> s == emptyset
with _. assert (feq s emptyset);
introduce s == emptyset ==> cardinality s = 0
wit... | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.l_and",
"Prims.l_iff",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.FiniteSet.Base.cardinality",
"Prims.eq2",
"FStar.FiniteSet.Base.emptyset",
"Prims.op_disEqua... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 length_zero_lemma: Prims.unit -> Lemma (length_zero_fact) | [] | FStar.FiniteSet.Base.length_zero_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.length_zero_fact) | {
"end_col": 20,
"end_line": 181,
"start_col": 2,
"start_line": 171
} |
FStar.Pervasives.Lemma | val union_of_disjoint_nonrepeating_lists_length_lemma (#a: eqtype) (xs1 xs2 xs3: list a)
: Lemma
(requires
list_nonrepeating xs1 /\ list_nonrepeating xs2 /\ list_nonrepeating xs3 /\
(forall x. ~(FLT.mem x xs1 /\ FLT.mem x xs2)) /\
(forall x. FLT.mem x xs3 <==> FLT.mem x xs1 \/ FLT.mem ... | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let rec union_of_disjoint_nonrepeating_lists_length_lemma (#a: eqtype) (xs1: list a) (xs2: list a) (xs3: list a)
: Lemma (requires list_nonrepeating xs1
/\ list_nonrepeating xs2
/\ list_nonrepeating xs3
/\ (forall x. ~(FLT.mem x xs1 /\ FLT.mem x xs2))
... | val union_of_disjoint_nonrepeating_lists_length_lemma (#a: eqtype) (xs1 xs2 xs3: list a)
: Lemma
(requires
list_nonrepeating xs1 /\ list_nonrepeating xs2 /\ list_nonrepeating xs3 /\
(forall x. ~(FLT.mem x xs1 /\ FLT.mem x xs2)) /\
(forall x. FLT.mem x xs3 <==> FLT.mem x xs1 \/ FLT.mem ... | false | null | true | match xs1 with
| [] -> nonrepeating_lists_with_same_elements_have_same_length xs2 xs3
| hd :: tl ->
union_of_disjoint_nonrepeating_lists_length_lemma tl xs2 (remove_from_nonrepeating_list hd xs3) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.eqtype",
"Prims.list",
"FStar.FiniteSet.Base.nonrepeating_lists_with_same_elements_have_same_length",
"FStar.FiniteSet.Base.union_of_disjoint_nonrepeating_lists_length_lemma",
"FStar.FiniteSet.Base.remove_from_nonrepeating_list",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"FStar.FiniteSet.Base... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 union_of_disjoint_nonrepeating_lists_length_lemma (#a: eqtype) (xs1 xs2 xs3: list a)
: Lemma
(requires
list_nonrepeating xs1 /\ list_nonrepeating xs2 /\ list_nonrepeating xs3 /\
(forall x. ~(FLT.mem x xs1 /\ FLT.mem x xs2)) /\
(forall x. FLT.mem x xs3 <==> FLT.mem x xs1 \/ FLT.mem ... | [
"recursion"
] | FStar.FiniteSet.Base.union_of_disjoint_nonrepeating_lists_length_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | xs1: Prims.list a -> xs2: Prims.list a -> xs3: Prims.list a
-> FStar.Pervasives.Lemma
(requires
FStar.FiniteSet.Base.list_nonrepeating xs1 /\ FStar.FiniteSet.Base.list_nonrepeating xs2 /\
FStar.FiniteSet.Base.list_nonrepeating xs3 /\
(forall (x: a). ~(FStar.List.Tot.Base.mem x xs1 /\ FSt... | {
"end_col": 111,
"end_line": 309,
"start_col": 2,
"start_line": 307
} |
FStar.Pervasives.Lemma | val nonrepeating_lists_with_same_elements_have_same_length (#a: eqtype) (s1 s2: list a)
: Lemma
(requires
list_nonrepeating s1 /\ list_nonrepeating s2 /\ (forall x. FLT.mem x s1 <==> FLT.mem x s2))
(ensures FLT.length s1 = FLT.length s2) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let rec nonrepeating_lists_with_same_elements_have_same_length (#a: eqtype) (s1: list a) (s2: list a)
: Lemma (requires list_nonrepeating s1 /\ list_nonrepeating s2 /\ (forall x. FLT.mem x s1 <==> FLT.mem x s2))
(ensures FLT.length s1 = FLT.length s2) =
match s1 with
| [] -> ()
| hd :: tl -> nonrepeating... | val nonrepeating_lists_with_same_elements_have_same_length (#a: eqtype) (s1 s2: list a)
: Lemma
(requires
list_nonrepeating s1 /\ list_nonrepeating s2 /\ (forall x. FLT.mem x s1 <==> FLT.mem x s2))
(ensures FLT.length s1 = FLT.length s2)
let rec nonrepeating_lists_with_same_elements_have_same_le... | false | null | true | match s1 with
| [] -> ()
| hd :: tl ->
nonrepeating_lists_with_same_elements_have_same_length tl (remove_from_nonrepeating_list hd s2) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.eqtype",
"Prims.list",
"FStar.FiniteSet.Base.nonrepeating_lists_with_same_elements_have_same_length",
"FStar.FiniteSet.Base.remove_from_nonrepeating_list",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"FStar.FiniteSet.Base.list_nonrepeating",
"Prims.l_Forall",
"Prims.l_iff",
"FStar.List.Tot.... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 nonrepeating_lists_with_same_elements_have_same_length (#a: eqtype) (s1 s2: list a)
: Lemma
(requires
list_nonrepeating s1 /\ list_nonrepeating s2 /\ (forall x. FLT.mem x s1 <==> FLT.mem x s2))
(ensures FLT.length s1 = FLT.length s2) | [
"recursion"
] | FStar.FiniteSet.Base.nonrepeating_lists_with_same_elements_have_same_length | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s1: Prims.list a -> s2: Prims.list a
-> FStar.Pervasives.Lemma
(requires
FStar.FiniteSet.Base.list_nonrepeating s1 /\ FStar.FiniteSet.Base.list_nonrepeating s2 /\
(forall (x: a). FStar.List.Tot.Base.mem x s1 <==> FStar.List.Tot.Base.mem x s2))
(ensures FStar.List.Tot.Base.length s1 = FStar... | {
"end_col": 111,
"end_line": 232,
"start_col": 2,
"start_line": 230
} |
FStar.Pervasives.Lemma | val intersection_idempotent_left_lemma: Prims.unit -> Lemma (intersection_idempotent_left_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let intersection_idempotent_left_lemma ()
: Lemma (intersection_idempotent_left_fact) =
introduce forall (a: eqtype) (s1: set a) (s2: set a). intersection s1 (intersection s1 s2) == intersection s1 s2
with assert (feq (intersection s1 (intersection s1 s2)) (intersection s1 s2)) | val intersection_idempotent_left_lemma: Prims.unit -> Lemma (intersection_idempotent_left_fact)
let intersection_idempotent_left_lemma () : Lemma (intersection_idempotent_left_fact) = | false | null | true | introduce forall (a: eqtype) (s1: set a) (s2: set a) . intersection s1 (intersection s1 s2) ==
intersection s1 s2
with assert (feq (intersection s1 (intersection s1 s2)) (intersection s1 s2)) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.eq2",
"FStar.FiniteSet.Base.intersection",
"Prims._assert",
"FStar.FunctionalExtensionality.feq",
"Prims.bool",
"Prims.squash",
"Prims.l_True",
"FStar.FiniteSet.Base.inter... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 intersection_idempotent_left_lemma: Prims.unit -> Lemma (intersection_idempotent_left_fact) | [] | FStar.FiniteSet.Base.intersection_idempotent_left_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit
-> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.intersection_idempotent_left_fact) | {
"end_col": 79,
"end_line": 298,
"start_col": 2,
"start_line": 297
} |
FStar.Pervasives.Lemma | val intersection_idempotent_right_lemma: Prims.unit -> Lemma (intersection_idempotent_right_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let intersection_idempotent_right_lemma ()
: Lemma (intersection_idempotent_right_fact) =
introduce forall (a: eqtype) (s1: set a) (s2: set a). intersection (intersection s1 s2) s2 == intersection s1 s2
with assert (feq (intersection (intersection s1 s2) s2) (intersection s1 s2)) | val intersection_idempotent_right_lemma: Prims.unit -> Lemma (intersection_idempotent_right_fact)
let intersection_idempotent_right_lemma () : Lemma (intersection_idempotent_right_fact) = | false | null | true | introduce forall (a: eqtype) (s1: set a) (s2: set a) . intersection (intersection s1 s2) s2 ==
intersection s1 s2
with assert (feq (intersection (intersection s1 s2) s2) (intersection s1 s2)) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.eq2",
"FStar.FiniteSet.Base.intersection",
"Prims._assert",
"FStar.FunctionalExtensionality.feq",
"Prims.bool",
"Prims.squash",
"Prims.l_True",
"FStar.FiniteSet.Base.inter... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 intersection_idempotent_right_lemma: Prims.unit -> Lemma (intersection_idempotent_right_fact) | [] | FStar.FiniteSet.Base.intersection_idempotent_right_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit
-> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.intersection_idempotent_right_fact) | {
"end_col": 79,
"end_line": 293,
"start_col": 2,
"start_line": 292
} |
FStar.Pervasives.Lemma | val union_of_disjoint_lemma: Prims.unit -> Lemma (union_of_disjoint_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let union_of_disjoint_lemma ()
: Lemma (union_of_disjoint_fact) =
introduce forall (a: eqtype) (s1: set a) (s2: set a). disjoint s1 s2 ==> difference (union s1 s2) s1 == s2 /\ difference (union s1 s2) s2 == s1
with
introduce disjoint s1 s2 ==> difference (union s1 s2) s1 == s2 /\ difference (union s1 s2) s2 == ... | val union_of_disjoint_lemma: Prims.unit -> Lemma (union_of_disjoint_fact)
let union_of_disjoint_lemma () : Lemma (union_of_disjoint_fact) = | false | null | true | introduce forall (a: eqtype) (s1: set a) (s2: set a) . disjoint s1 s2 ==>
difference (union s1 s2) s1 == s2 /\ difference (union s1 s2) s2 == s1
with introduce disjoint s1 s2 ==> difference (union s1 s2) s1 == s2 /\
difference (union s1 s2) s2 == s1
with _. (assert (feq (difference (union s1 s2) s1) s2);
assert (feq ... | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.l_imp",
"FStar.FiniteSet.Base.disjoint",
"Prims.l_and",
"Prims.eq2",
"FStar.FiniteSet.Base.difference",
"FStar.FiniteSet.Base.union",
"FStar.Classical.Sugar.implies_intro",
... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 union_of_disjoint_lemma: Prims.unit -> Lemma (union_of_disjoint_fact) | [] | FStar.FiniteSet.Base.union_of_disjoint_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.union_of_disjoint_fact) | {
"end_col": 5,
"end_line": 274,
"start_col": 2,
"start_line": 268
} |
FStar.Pervasives.Lemma | val insert_nonmember_cardinality_lemma: Prims.unit -> Lemma (insert_nonmember_cardinality_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let insert_nonmember_cardinality_lemma ()
: Lemma (insert_nonmember_cardinality_fact) =
introduce forall (a: eqtype) (s: set a) (x: a). not (mem x s) ==> cardinality (insert x s) = cardinality s + 1
with
introduce not (mem x s) ==> cardinality (insert x s) = cardinality s + 1
with _. (
reveal_opaque (... | val insert_nonmember_cardinality_lemma: Prims.unit -> Lemma (insert_nonmember_cardinality_fact)
let insert_nonmember_cardinality_lemma () : Lemma (insert_nonmember_cardinality_fact) = | false | null | true | introduce forall (a: eqtype) (s: set a) (x: a) . not (mem x s) ==>
cardinality (insert x s) = cardinality s + 1
with introduce not (mem x s) ==> cardinality (insert x s) = cardinality s + 1
with _. (reveal_opaque (`%cardinality) (cardinality #a);
nonrepeating_lists_with_same_elements_have_same_length (x :: (set_as_li... | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_Negation",
"FStar.FiniteSet.Base.mem",
"Prims.op_Equality",
"Prims.int",
"FStar.FiniteSet.Base.cardinality",
"FStar.FiniteSet.Base.insert",
... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 insert_nonmember_cardinality_lemma: Prims.unit -> Lemma (insert_nonmember_cardinality_fact) | [] | FStar.FiniteSet.Base.insert_nonmember_cardinality_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit
-> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.insert_nonmember_cardinality_fact) | {
"end_col": 5,
"end_line": 252,
"start_col": 2,
"start_line": 246
} |
FStar.Pervasives.Lemma | val set_as_list_cardinality_lemma: Prims.unit -> Lemma (set_as_list_cardinality_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let set_as_list_cardinality_lemma ()
: Lemma (set_as_list_cardinality_fact) =
introduce forall (a: eqtype) (s: set a). FLT.length (set_as_list s) = cardinality s
with reveal_opaque (`%cardinality) (cardinality #a) | val set_as_list_cardinality_lemma: Prims.unit -> Lemma (set_as_list_cardinality_fact)
let set_as_list_cardinality_lemma () : Lemma (set_as_list_cardinality_fact) = | false | null | true | introduce forall (a: eqtype) (s: set a) . FLT.length (set_as_list s) = cardinality s
with reveal_opaque (`%cardinality) (cardinality #a) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.List.Tot.Base.length",
"FStar.FiniteSet.Base.set_as_list",
"FStar.FiniteSet.Base.cardinality",
"FStar.Pervasives.reveal_opaque... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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_as_list_cardinality_lemma: Prims.unit -> Lemma (set_as_list_cardinality_fact) | [] | FStar.FiniteSet.Base.set_as_list_cardinality_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.set_as_list_cardinality_fact) | {
"end_col": 53,
"end_line": 436,
"start_col": 2,
"start_line": 435
} |
FStar.Pervasives.Lemma | val insert_remove_lemma: Prims.unit -> Lemma (insert_remove_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let insert_remove_lemma ()
: Lemma (insert_remove_fact) =
introduce forall (a: eqtype) (x: a) (s: set a). mem x s = true ==> insert x (remove x s) == s
with
introduce mem x s = true ==> insert x (remove x s) == s
with _. insert_remove_helper a x s | val insert_remove_lemma: Prims.unit -> Lemma (insert_remove_fact)
let insert_remove_lemma () : Lemma (insert_remove_fact) = | false | null | true | introduce forall (a: eqtype) (x: a) (s: set a) . mem x s = true ==> insert x (remove x s) == s
with introduce mem x s = true ==> insert x (remove x s) == s
with _. insert_remove_helper a x s | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_Equality",
"Prims.bool",
"FStar.FiniteSet.Base.mem",
"Prims.eq2",
"FStar.FiniteSet.Base.insert",
"FStar.FiniteSet.Base.remove",
"FStar.Cla... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 insert_remove_lemma: Prims.unit -> Lemma (insert_remove_fact) | [] | FStar.FiniteSet.Base.insert_remove_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.insert_remove_fact) | {
"end_col": 39,
"end_line": 420,
"start_col": 2,
"start_line": 417
} |
FStar.Pervasives.Lemma | val union_idempotent_left_lemma: Prims.unit -> Lemma (union_idempotent_left_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let union_idempotent_left_lemma ()
: Lemma (union_idempotent_left_fact) =
introduce forall (a: eqtype) (s1: set a) (s2: set a). union s1 (union s1 s2) == union s1 s2
with assert (feq (union s1 (union s1 s2)) (union s1 s2)) | val union_idempotent_left_lemma: Prims.unit -> Lemma (union_idempotent_left_fact)
let union_idempotent_left_lemma () : Lemma (union_idempotent_left_fact) = | false | null | true | introduce forall (a: eqtype) (s1: set a) (s2: set a) . union s1 (union s1 s2) == union s1 s2
with assert (feq (union s1 (union s1 s2)) (union s1 s2)) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.eq2",
"FStar.FiniteSet.Base.union",
"Prims._assert",
"FStar.FunctionalExtensionality.feq",
"Prims.bool",
"Prims.squash",
"Prims.l_True",
"FStar.FiniteSet.Base.union_idempo... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 union_idempotent_left_lemma: Prims.unit -> Lemma (union_idempotent_left_fact) | [] | FStar.FiniteSet.Base.union_idempotent_left_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.union_idempotent_left_fact) | {
"end_col": 58,
"end_line": 288,
"start_col": 2,
"start_line": 287
} |
FStar.Pervasives.Lemma | val cardinality_matches_difference_plus_intersection_lemma (#a: eqtype) (s1 s2: set a)
: Lemma
(ensures cardinality s1 = cardinality (difference s1 s2) + cardinality (intersection s1 s2)) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let cardinality_matches_difference_plus_intersection_lemma (#a: eqtype) (s1: set a) (s2: set a)
: Lemma (ensures cardinality s1 = cardinality (difference s1 s2) + cardinality (intersection s1 s2)) =
union_of_disjoint_sets_cardinality_lemma (difference s1 s2) (intersection s1 s2);
assert (feq s1 (union (difference s... | val cardinality_matches_difference_plus_intersection_lemma (#a: eqtype) (s1 s2: set a)
: Lemma
(ensures cardinality s1 = cardinality (difference s1 s2) + cardinality (intersection s1 s2))
let cardinality_matches_difference_plus_intersection_lemma (#a: eqtype) (s1 s2: set a)
: Lemma
(ensures cardinality ... | false | null | true | union_of_disjoint_sets_cardinality_lemma (difference s1 s2) (intersection s1 s2);
assert (feq s1 (union (difference s1 s2) (intersection s1 s2))) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"Prims._assert",
"FStar.FunctionalExtensionality.feq",
"Prims.bool",
"FStar.FiniteSet.Base.union",
"FStar.FiniteSet.Base.difference",
"FStar.FiniteSet.Base.intersection",
"Prims.unit",
"FStar.FiniteSet.Base.union_of_disjoint_sets_cardinality_lemma",
"P... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 cardinality_matches_difference_plus_intersection_lemma (#a: eqtype) (s1 s2: set a)
: Lemma
(ensures cardinality s1 = cardinality (difference s1 s2) + cardinality (intersection s1 s2)) | [] | FStar.FiniteSet.Base.cardinality_matches_difference_plus_intersection_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s1: FStar.FiniteSet.Base.set a -> s2: FStar.FiniteSet.Base.set a
-> FStar.Pervasives.Lemma
(ensures
FStar.FiniteSet.Base.cardinality s1 =
FStar.FiniteSet.Base.cardinality (FStar.FiniteSet.Base.difference s1 s2) +
FStar.FiniteSet.Base.cardinality (FStar.FiniteSet.Base.intersection s1 s2)) | {
"end_col": 65,
"end_line": 326,
"start_col": 2,
"start_line": 325
} |
FStar.Pervasives.Lemma | val insert_remove_helper (a: eqtype) (x: a) (s: set a)
: Lemma (requires mem x s) (ensures insert x (remove x s) == s) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let insert_remove_helper (a: eqtype) (x: a) (s: set a)
: Lemma (requires mem x s)
(ensures insert x (remove x s) == s) =
assert (feq s (insert x (remove x s))) | val insert_remove_helper (a: eqtype) (x: a) (s: set a)
: Lemma (requires mem x s) (ensures insert x (remove x s) == s)
let insert_remove_helper (a: eqtype) (x: a) (s: set a)
: Lemma (requires mem x s) (ensures insert x (remove x s) == s) = | false | null | true | assert (feq s (insert x (remove x s))) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"Prims._assert",
"FStar.FunctionalExtensionality.feq",
"Prims.bool",
"FStar.FiniteSet.Base.insert",
"FStar.FiniteSet.Base.remove",
"Prims.unit",
"Prims.b2t",
"FStar.FiniteSet.Base.mem",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 insert_remove_helper (a: eqtype) (x: a) (s: set a)
: Lemma (requires mem x s) (ensures insert x (remove x s) == s) | [] | FStar.FiniteSet.Base.insert_remove_helper | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: Prims.eqtype -> x: a -> s: FStar.FiniteSet.Base.set a
-> FStar.Pervasives.Lemma (requires FStar.FiniteSet.Base.mem x s)
(ensures FStar.FiniteSet.Base.insert x (FStar.FiniteSet.Base.remove x s) == s) | {
"end_col": 40,
"end_line": 413,
"start_col": 2,
"start_line": 413
} |
FStar.Pervasives.Lemma | val union_is_differences_and_intersection (#a: eqtype) (s1 s2: set a)
: Lemma
(union s1 s2 == union (union (difference s1 s2) (intersection s1 s2)) (difference s2 s1)) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let union_is_differences_and_intersection (#a: eqtype) (s1: set a) (s2: set a)
: Lemma (union s1 s2 == union (union (difference s1 s2) (intersection s1 s2)) (difference s2 s1)) =
assert (feq (union s1 s2) (union (union (difference s1 s2) (intersection s1 s2)) (difference s2 s1))) | val union_is_differences_and_intersection (#a: eqtype) (s1 s2: set a)
: Lemma
(union s1 s2 == union (union (difference s1 s2) (intersection s1 s2)) (difference s2 s1))
let union_is_differences_and_intersection (#a: eqtype) (s1 s2: set a)
: Lemma
(union s1 s2 == union (union (difference s1 s2) (intersect... | false | null | true | assert (feq (union s1 s2) (union (union (difference s1 s2) (intersection s1 s2)) (difference s2 s1))
) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"Prims._assert",
"FStar.FunctionalExtensionality.feq",
"Prims.bool",
"FStar.FiniteSet.Base.union",
"FStar.FiniteSet.Base.difference",
"FStar.FiniteSet.Base.intersection",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FS... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 union_is_differences_and_intersection (#a: eqtype) (s1 s2: set a)
: Lemma
(union s1 s2 == union (union (difference s1 s2) (intersection s1 s2)) (difference s2 s1)) | [] | FStar.FiniteSet.Base.union_is_differences_and_intersection | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s1: FStar.FiniteSet.Base.set a -> s2: FStar.FiniteSet.Base.set a
-> FStar.Pervasives.Lemma
(ensures
FStar.FiniteSet.Base.union s1 s2 ==
FStar.FiniteSet.Base.union (FStar.FiniteSet.Base.union (FStar.FiniteSet.Base.difference s1 s2)
(FStar.FiniteSet.Base.intersection s1 s2))
(FStar.F... | {
"end_col": 103,
"end_line": 330,
"start_col": 2,
"start_line": 330
} |
FStar.Pervasives.Lemma | val union_idempotent_right_lemma: Prims.unit -> Lemma (union_idempotent_right_fact) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let union_idempotent_right_lemma ()
: Lemma (union_idempotent_right_fact) =
introduce forall (a: eqtype) (s1: set a) (s2: set a). union (union s1 s2) s2 == union s1 s2
with assert (feq (union (union s1 s2) s2) (union s1 s2)) | val union_idempotent_right_lemma: Prims.unit -> Lemma (union_idempotent_right_fact)
let union_idempotent_right_lemma () : Lemma (union_idempotent_right_fact) = | false | null | true | introduce forall (a: eqtype) (s1: set a) (s2: set a) . union (union s1 s2) s2 == union s1 s2
with assert (feq (union (union s1 s2) s2) (union s1 s2)) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.eqtype",
"Prims.l_Forall",
"FStar.FiniteSet.Base.set",
"Prims.eq2",
"FStar.FiniteSet.Base.union",
"Prims._assert",
"FStar.FunctionalExtensionality.feq",
"Prims.bool",
"Prims.squash",
"Prims.l_True",
"FStar.FiniteSet.Base.union_idempo... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 union_idempotent_right_lemma: Prims.unit -> Lemma (union_idempotent_right_fact) | [] | FStar.FiniteSet.Base.union_idempotent_right_lemma | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.FiniteSet.Base.union_idempotent_right_fact) | {
"end_col": 58,
"end_line": 283,
"start_col": 2,
"start_line": 282
} |
FStar.Pervasives.Lemma | val remove_insert_helper (a: eqtype) (x: a) (s: set a)
: Lemma (requires mem x s = false) (ensures remove x (insert x s) == s) | [
{
"abbrev": false,
"full_module": "FStar.FunctionalExtensionality",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
... | false | let remove_insert_helper (a: eqtype) (x: a) (s: set a)
: Lemma (requires mem x s = false)
(ensures remove x (insert x s) == s) =
assert (feq s (remove x (insert x s))) | val remove_insert_helper (a: eqtype) (x: a) (s: set a)
: Lemma (requires mem x s = false) (ensures remove x (insert x s) == s)
let remove_insert_helper (a: eqtype) (x: a) (s: set a)
: Lemma (requires mem x s = false) (ensures remove x (insert x s) == s) = | false | null | true | assert (feq s (remove x (insert x s))) | {
"checked_file": "FStar.FiniteSet.Base.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.IndefiniteDescription.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classi... | [
"lemma"
] | [
"Prims.eqtype",
"FStar.FiniteSet.Base.set",
"Prims._assert",
"FStar.FunctionalExtensionality.feq",
"Prims.bool",
"FStar.FiniteSet.Base.remove",
"FStar.FiniteSet.Base.insert",
"Prims.unit",
"Prims.b2t",
"Prims.op_Equality",
"FStar.FiniteSet.Base.mem",
"Prims.squash",
"Prims.eq2",
"Prims.Nil... | [] | (*
Copyright 2008-2021 John Li, Jay Lorch, Rustan Leino, Alex Summers,
Dan Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
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 c... | false | false | FStar.FiniteSet.Base.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 remove_insert_helper (a: eqtype) (x: a) (s: set a)
: Lemma (requires mem x s = false) (ensures remove x (insert x s) == s) | [] | FStar.FiniteSet.Base.remove_insert_helper | {
"file_name": "ulib/FStar.FiniteSet.Base.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: Prims.eqtype -> x: a -> s: FStar.FiniteSet.Base.set a
-> FStar.Pervasives.Lemma (requires FStar.FiniteSet.Base.mem x s = false)
(ensures FStar.FiniteSet.Base.remove x (FStar.FiniteSet.Base.insert x s) == s) | {
"end_col": 40,
"end_line": 425,
"start_col": 2,
"start_line": 425
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Seq.Properties",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.Types_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
... | false | let pow2_24 = 0x1000000 | let pow2_24 = | false | null | false | 0x1000000 | {
"checked_file": "Vale.AES.GCTR.fst.checked",
"dependencies": [
"Vale.Poly1305.Bitvectors.fsti.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.TypesNative_s.fst.checked",
"Vale.... | [
"total"
] | [] | [] | module Vale.AES.GCTR
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
open Vale.AES.Type... | false | true | Vale.AES.GCTR.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 pow2_24 : Prims.int | [] | Vale.AES.GCTR.pow2_24 | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 30,
"end_line": 296,
"start_col": 21,
"start_line": 296
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Seq.Properties",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.Types_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
... | false | let nat24 = natN pow2_24 | let nat24 = | false | null | false | natN pow2_24 | {
"checked_file": "Vale.AES.GCTR.fst.checked",
"dependencies": [
"Vale.Poly1305.Bitvectors.fsti.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.TypesNative_s.fst.checked",
"Vale.... | [
"total"
] | [
"Vale.Def.Words_s.natN",
"Vale.AES.GCTR.pow2_24"
] | [] | module Vale.AES.GCTR
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
open Vale.AES.Type... | false | true | Vale.AES.GCTR.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 nat24 : Type0 | [] | Vale.AES.GCTR.nat24 | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 24,
"end_line": 297,
"start_col": 12,
"start_line": 297
} | |
FStar.Pervasives.Lemma | val gctr_partial_opaque_init (alg:algorithm) (plain cipher:seq quad32) (key:seq nat32) (icb:quad32) : Lemma
(requires is_aes_key_LE alg key)
(ensures gctr_partial alg 0 plain cipher key icb) | [
{
"abbrev": false,
"full_module": "Vale.AES.Types_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": fal... | false | let gctr_partial_opaque_init alg plain cipher key icb =
gctr_partial_reveal ();
() | val gctr_partial_opaque_init (alg:algorithm) (plain cipher:seq quad32) (key:seq nat32) (icb:quad32) : Lemma
(requires is_aes_key_LE alg key)
(ensures gctr_partial alg 0 plain cipher key icb)
let gctr_partial_opaque_init alg plain cipher key icb = | false | null | true | gctr_partial_reveal ();
() | {
"checked_file": "Vale.AES.GCTR.fst.checked",
"dependencies": [
"Vale.Poly1305.Bitvectors.fsti.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.TypesNative_s.fst.checked",
"Vale.... | [
"lemma"
] | [
"Vale.AES.AES_common_s.algorithm",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.nat32",
"Prims.unit",
"Vale.AES.GCTR.gctr_partial_reveal"
] | [] | module Vale.AES.GCTR
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
open Vale.AES.Type... | false | false | Vale.AES.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"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 gctr_partial_opaque_init (alg:algorithm) (plain cipher:seq quad32) (key:seq nat32) (icb:quad32) : Lemma
(requires is_aes_key_LE alg key)
(ensures gctr_partial alg 0 plain cipher key icb) | [] | Vale.AES.GCTR.gctr_partial_opaque_init | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
alg: Vale.AES.AES_common_s.algorithm ->
plain: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
cipher: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
key: FStar.Seq.Base.seq Vale.Def.Types_s.nat32 ->
icb: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma (requires Vale.AES.AES_s.is_aes_key_LE alg ke... | {
"end_col": 4,
"end_line": 54,
"start_col": 2,
"start_line": 53
} |
FStar.Pervasives.Lemma | val gctr_encrypt_recursive_length
(icb: quad32)
(plain: gctr_plain_internal_LE)
(alg: algorithm)
(key: aes_key_LE alg)
(i: int)
: Lemma (requires True)
(ensures length (gctr_encrypt_recursive icb plain alg key i) == length plain)
(decreases %[length plain])
[SMTPat (l... | [
{
"abbrev": false,
"full_module": "Vale.AES.Types_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Math.Lemmas",
"short_module": null
},
{
"abbrev": false,
"fu... | false | let rec gctr_encrypt_recursive_length (icb:quad32) (plain:gctr_plain_internal_LE)
(alg:algorithm) (key:aes_key_LE alg) (i:int) : Lemma
(requires True)
(ensures length (gctr_encrypt_recursive icb plain alg key i) == length plain)
(decreases %[length plain])
[SMTPat (length (... | val gctr_encrypt_recursive_length
(icb: quad32)
(plain: gctr_plain_internal_LE)
(alg: algorithm)
(key: aes_key_LE alg)
(i: int)
: Lemma (requires True)
(ensures length (gctr_encrypt_recursive icb plain alg key i) == length plain)
(decreases %[length plain])
[SMTPat (l... | false | null | true | if length plain = 0 then () else gctr_encrypt_recursive_length icb (tail plain) alg key (i + 1) | {
"checked_file": "Vale.AES.GCTR.fst.checked",
"dependencies": [
"Vale.Poly1305.Bitvectors.fsti.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.TypesNative_s.fst.checked",
"Vale.... | [
"lemma",
""
] | [
"Vale.Def.Types_s.quad32",
"Vale.AES.GCTR_s.gctr_plain_internal_LE",
"Vale.AES.AES_common_s.algorithm",
"Vale.AES.AES_s.aes_key_LE",
"Prims.int",
"Prims.op_Equality",
"FStar.Seq.Base.length",
"Prims.bool",
"Vale.AES.GCTR.gctr_encrypt_recursive_length",
"FStar.Seq.Properties.tail",
"Prims.op_Addi... | [] | module Vale.AES.GCTR
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
open Vale.AES.Type... | false | false | Vale.AES.GCTR.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"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 gctr_encrypt_recursive_length
(icb: quad32)
(plain: gctr_plain_internal_LE)
(alg: algorithm)
(key: aes_key_LE alg)
(i: int)
: Lemma (requires True)
(ensures length (gctr_encrypt_recursive icb plain alg key i) == length plain)
(decreases %[length plain])
[SMTPat (l... | [
"recursion"
] | Vale.AES.GCTR.gctr_encrypt_recursive_length | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
icb: Vale.Def.Types_s.quad32 ->
plain: Vale.AES.GCTR_s.gctr_plain_internal_LE ->
alg: Vale.AES.AES_common_s.algorithm ->
key: Vale.AES.AES_s.aes_key_LE alg ->
i: Prims.int
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.length (Vale.AES.GCTR_s.gctr_encrypt_recursive icb plain alg ... | {
"end_col": 69,
"end_line": 113,
"start_col": 2,
"start_line": 112
} |
FStar.Pervasives.Lemma | val lemma_ishl_32 (x: nat32) (k: nat) : Lemma (ensures ishl #pow2_32 x k == x * pow2 k % pow2_32) | [
{
"abbrev": false,
"full_module": "FStar.Seq.Properties",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.Types_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
... | false | let lemma_ishl_32 (x:nat32) (k:nat) : Lemma
(ensures ishl #pow2_32 x k == x * pow2 k % pow2_32)
=
Vale.Def.TypesNative_s.reveal_ishl 32 x k;
FStar.UInt.shift_left_value_lemma #32 x k;
() | val lemma_ishl_32 (x: nat32) (k: nat) : Lemma (ensures ishl #pow2_32 x k == x * pow2 k % pow2_32)
let lemma_ishl_32 (x: nat32) (k: nat) : Lemma (ensures ishl #pow2_32 x k == x * pow2 k % pow2_32) = | false | null | true | Vale.Def.TypesNative_s.reveal_ishl 32 x k;
FStar.UInt.shift_left_value_lemma #32 x k;
() | {
"checked_file": "Vale.AES.GCTR.fst.checked",
"dependencies": [
"Vale.Poly1305.Bitvectors.fsti.checked",
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.TypesNative_s.fst.checked",
"Vale.... | [
"lemma"
] | [
"Vale.Def.Types_s.nat32",
"Prims.nat",
"Prims.unit",
"FStar.UInt.shift_left_value_lemma",
"Vale.Def.TypesNative_s.reveal_ishl",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"Vale.Def.Types_s.ishl",
"Vale.Def.Words_s.pow2_32",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Prims.pow... | [] | module Vale.AES.GCTR
open Vale.Def.Opaque_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.AES.AES_s
open Vale.AES.GCTR_s
open Vale.AES.GCM_helpers
open FStar.Math.Lemmas
open Vale.Lib.Seqs
open Vale.AES.Type... | false | false | Vale.AES.GCTR.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 lemma_ishl_32 (x: nat32) (k: nat) : Lemma (ensures ishl #pow2_32 x k == x * pow2 k % pow2_32) | [] | Vale.AES.GCTR.lemma_ishl_32 | {
"file_name": "vale/code/crypto/aes/Vale.AES.GCTR.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Types_s.nat32 -> k: Prims.nat
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Types_s.ishl x k == x * Prims.pow2 k % Vale.Def.Words_s.pow2_32) | {
"end_col": 4,
"end_line": 283,
"start_col": 2,
"start_line": 281
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.