effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Pure | val enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: enum_repr e)
: Pure (enum_key e) (requires True) (ensures (fun y -> L.assoc y e == Some r)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e) | val enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: enum_repr e)
: Pure (enum_key e) (requires True) (ensures (fun y -> L.assoc y e == Some r))
let enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: enum_repr e)
: Pure (enum_key e) (requires True) (ensures (fun y -> L.assoc y e == Some r)) = | false | null | false | map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_repr",
"LowParse.Spec.Enum.enum_key",
"Prims.unit",
"FStar.List.Tot.Properties.assoc_mem",
"LowParse.Spec.Enum.assoc_flip_elim",
"FStar.Pervasives.Native.__proj__Some__item__v",
"FStar.List.Tot.Base.assoc",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.List.Tot.Base.map",
"LowParse.Spec.Enum.flip",
"LowParse.Spec.Enum.list_map",
"LowParse.Spec.Enum.map_fst_flip",
"Prims.l_True",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Some"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: enum_repr e)
: Pure (enum_key e) (requires True) (ensures (fun y -> L.assoc y e == Some r)) | [] | LowParse.Spec.Enum.enum_key_of_repr | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.enum key repr -> r: LowParse.Spec.Enum.enum_repr e
-> Prims.Pure (LowParse.Spec.Enum.enum_key e) | {
"end_col": 19,
"end_line": 139,
"start_col": 2,
"start_line": 133
} |
Prims.Tot | val parse_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l) | val parse_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
let parse_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key) = | false | null | false | (parse_enum_key p l) `parse_synth` (synth_total_enum_key l) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.parse_enum_key",
"LowParse.Spec.Enum.synth_total_enum_key"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key) | [] | LowParse.Spec.Enum.parse_total_enum_key | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.parser k repr -> l: LowParse.Spec.Enum.total_enum key repr
-> LowParse.Spec.Base.parser (LowParse.Spec.Combinators.parse_filter_kind k) key | {
"end_col": 59,
"end_line": 354,
"start_col": 2,
"start_line": 354
} |
Prims.Pure | val enum_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Pure (enum_repr e) (requires True) (ensures (fun r -> L.assoc k e == Some r)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e) | val enum_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Pure (enum_repr e) (requires True) (ensures (fun r -> L.assoc k e == Some r))
let enum_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Pure (enum_repr e) (requires True) (ensures (fun r -> L.assoc k e == Some r)) = | false | null | false | L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.enum_repr",
"Prims.unit",
"LowParse.Spec.Enum.map_fst_flip",
"FStar.List.Tot.Properties.assoc_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.flip",
"LowParse.Spec.Enum.assoc_flip_intro",
"FStar.Pervasives.Native.__proj__Some__item__v",
"FStar.List.Tot.Base.assoc",
"Prims.l_True",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Some"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Pure (enum_repr e) (requires True) (ensures (fun r -> L.assoc k e == Some r)) | [] | LowParse.Spec.Enum.enum_repr_of_key | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.enum key repr -> k: LowParse.Spec.Enum.enum_key e
-> Prims.Pure (LowParse.Spec.Enum.enum_repr e) | {
"end_col": 20,
"end_line": 180,
"start_col": 2,
"start_line": 175
} |
FStar.Pervasives.Lemma | val r_reflexive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_reflexive_t t r)
: Lemma (r_reflexive_prop t r) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi | val r_reflexive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_reflexive_t t r)
: Lemma (r_reflexive_prop t r)
let r_reflexive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_reflexive_t t r)
: Lemma (r_reflexive_prop t r) = | false | null | true | Classical.forall_intro phi | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"LowParse.Spec.Enum.r_reflexive_t",
"FStar.Classical.forall_intro",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"LowParse.Spec.Enum.r_reflexive_prop",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val r_reflexive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_reflexive_t t r)
: Lemma (r_reflexive_prop t r) | [] | LowParse.Spec.Enum.r_reflexive_t_elim | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | t: Type -> r: (_: t -> _: t -> Prims.GTot Type0) -> phi: LowParse.Spec.Enum.r_reflexive_t t r
-> FStar.Pervasives.Lemma (ensures LowParse.Spec.Enum.r_reflexive_prop t r) | {
"end_col": 28,
"end_line": 479,
"start_col": 2,
"start_line": 479
} |
FStar.Pervasives.Lemma | val serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma (serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x | val serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma (serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma (serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x)) = | false | null | true | serialize_enum_key_synth_inverse e;
serialize_synth_eq (parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Combinators.serialize_synth_eq",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Enum.parse_enum_key_cond",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Spec.Enum.parse_enum_key_synth",
"LowParse.Spec.Combinators.serialize_filter",
"LowParse.Spec.Enum.serialize_enum_key_synth_recip",
"Prims.unit",
"LowParse.Spec.Enum.serialize_enum_key_synth_inverse",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.Enum.parse_enum_key",
"LowParse.Spec.Enum.serialize_enum_key",
"LowParse.Spec.Enum.enum_repr_of_key",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma (serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x)) | [] | LowParse.Spec.Enum.serialize_enum_key_eq | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s: LowParse.Spec.Base.serializer p ->
e: LowParse.Spec.Enum.enum key repr ->
x: LowParse.Spec.Enum.enum_key e
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.serialize (LowParse.Spec.Enum.serialize_enum_key p s e) x ==
LowParse.Spec.Base.serialize s (LowParse.Spec.Enum.enum_repr_of_key e x)) | {
"end_col": 5,
"end_line": 243,
"start_col": 2,
"start_line": 236
} |
Prims.Tot | val total_of_maybe_enum_key (#key #repr: eqtype) (e: total_enum key repr) (k: maybe_enum_key e)
: Tot (maybe_total_enum_key e) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r | val total_of_maybe_enum_key (#key #repr: eqtype) (e: total_enum key repr) (k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
let total_of_maybe_enum_key (#key #repr: eqtype) (e: total_enum key repr) (k: maybe_enum_key e)
: Tot (maybe_total_enum_key e) = | false | null | false | match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.TotalKnown",
"LowParse.Spec.Enum.unknown_enum_repr",
"LowParse.Spec.Enum.TotalUnknown",
"LowParse.Spec.Enum.maybe_total_enum_key"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val total_of_maybe_enum_key (#key #repr: eqtype) (e: total_enum key repr) (k: maybe_enum_key e)
: Tot (maybe_total_enum_key e) | [] | LowParse.Spec.Enum.total_of_maybe_enum_key | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.total_enum key repr -> k: LowParse.Spec.Enum.maybe_enum_key e
-> LowParse.Spec.Enum.maybe_total_enum_key e | {
"end_col": 31,
"end_line": 433,
"start_col": 2,
"start_line": 431
} |
Prims.Pure | val enum_tail' (#key #repr: eqtype) (e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures
(fun y ->
Cons? e ==>
(let _ :: y' = e in
y == y'))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> [] | val enum_tail' (#key #repr: eqtype) (e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures
(fun y ->
Cons? e ==>
(let _ :: y' = e in
y == y')))
let enum_tail' (#key #repr: eqtype) (e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures
(fun y ->
Cons? e ==>
(let _ :: y' = e in
y == y'))) = | false | null | false | match e with
| _ :: y -> y
| _ -> [] | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"FStar.Pervasives.Native.tuple2",
"Prims.list",
"Prims.Nil",
"Prims.l_True",
"Prims.l_imp",
"Prims.b2t",
"Prims.uu___is_Cons",
"Prims.eq2",
"Prims.logical"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_tail' (#key #repr: eqtype) (e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures
(fun y ->
Cons? e ==>
(let _ :: y' = e in
y == y'))) | [] | LowParse.Spec.Enum.enum_tail' | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.enum key repr -> Prims.Pure (LowParse.Spec.Enum.enum key repr) | {
"end_col": 36,
"end_line": 605,
"start_col": 2,
"start_line": 605
} |
Prims.Tot | val synth_total_enum_key_recip (#key #repr: eqtype) (l: total_enum key repr) (k: key)
: Tot (k': enum_key l {synth_total_enum_key l k' == k}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k | val synth_total_enum_key_recip (#key #repr: eqtype) (l: total_enum key repr) (k: key)
: Tot (k': enum_key l {synth_total_enum_key l k' == k})
let synth_total_enum_key_recip (#key #repr: eqtype) (l: total_enum key repr) (k: key)
: Tot (k': enum_key l {synth_total_enum_key l k' == k}) = | false | null | false | k | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Enum.enum_key",
"Prims.eq2",
"LowParse.Spec.Enum.synth_total_enum_key"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val synth_total_enum_key_recip (#key #repr: eqtype) (l: total_enum key repr) (k: key)
: Tot (k': enum_key l {synth_total_enum_key l k' == k}) | [] | LowParse.Spec.Enum.synth_total_enum_key_recip | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l: LowParse.Spec.Enum.total_enum key repr -> k: key
-> k': LowParse.Spec.Enum.enum_key l {LowParse.Spec.Enum.synth_total_enum_key l k' == k} | {
"end_col": 3,
"end_line": 362,
"start_col": 2,
"start_line": 362
} |
FStar.Pervasives.Lemma | val r_transitive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_transitive_t t r)
: Lemma (r_transitive_prop t r) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi | val r_transitive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_transitive_t t r)
: Lemma (r_transitive_prop t r)
let r_transitive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_transitive_t t r)
: Lemma (r_transitive_prop t r) = | false | null | true | Classical.forall_intro_3 phi | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"LowParse.Spec.Enum.r_transitive_t",
"FStar.Classical.forall_intro_3",
"Prims.l_imp",
"Prims.l_and",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"LowParse.Spec.Enum.r_transitive_prop",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val r_transitive_t_elim (t: Type) (r: (t -> t -> GTot Type0)) (phi: r_transitive_t t r)
: Lemma (r_transitive_prop t r) | [] | LowParse.Spec.Enum.r_transitive_t_elim | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | t: Type -> r: (_: t -> _: t -> Prims.GTot Type0) -> phi: LowParse.Spec.Enum.r_transitive_t t r
-> FStar.Pervasives.Lemma (ensures LowParse.Spec.Enum.r_transitive_prop t r) | {
"end_col": 30,
"end_line": 500,
"start_col": 2,
"start_line": 500
} |
Prims.Tot | val serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) () | val serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e)) = | false | null | false | serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) () | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Combinators.serialize_synth",
"LowParse.Spec.Enum.maybe_total_enum_key",
"LowParse.Spec.Enum.maybe_total_enum_key_of_repr",
"LowParse.Spec.Enum.repr_of_maybe_total_enum_key",
"LowParse.Spec.Enum.parse_maybe_total_enum_key"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e)) | [] | LowParse.Spec.Enum.serialize_maybe_total_enum_key | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k repr ->
s: LowParse.Spec.Base.serializer p ->
e: LowParse.Spec.Enum.total_enum key repr
-> LowParse.Spec.Base.serializer (LowParse.Spec.Enum.parse_maybe_total_enum_key p e) | {
"end_col": 90,
"end_line": 413,
"start_col": 2,
"start_line": 413
} |
FStar.Pervasives.Lemma | val list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t)
: Lemma (L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2 | val list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t)
: Lemma (L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t)
: Lemma (L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2) = | false | null | true | list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2 | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"Prims.list",
"FStar.List.Tot.Properties.append_assoc",
"FStar.List.Tot.Base.rev",
"Prims.Cons",
"Prims.Nil",
"Prims.unit",
"LowParse.Spec.Enum.list_rev_cons",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t)
: Lemma (L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2) | [] | LowParse.Spec.Enum.list_append_rev_cons | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l1: Prims.list t -> x: t -> l2: Prims.list t
-> FStar.Pervasives.Lemma
(ensures FStar.List.Tot.Base.rev l1 @ x :: l2 == FStar.List.Tot.Base.rev (x :: l1) @ l2) | {
"end_col": 34,
"end_line": 806,
"start_col": 2,
"start_line": 805
} |
FStar.Pervasives.Lemma | val parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input ==
(match parse p input with
| Some (x, consumed) ->
(match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None)
| _ -> None)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input | val parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input ==
(match parse p input with
| Some (x, consumed) ->
(match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None)
| _ -> None))
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input ==
(match parse p input with
| Some (x, consumed) ->
(match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None)
| _ -> None)) = | false | null | true | parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` (parse_enum_key_cond e)) (parse_enum_key_synth e) input | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Enum.enum",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.parse_synth_eq",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Enum.parse_enum_key_cond",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Spec.Enum.parse_enum_key_synth",
"Prims.unit",
"LowParse.Spec.Combinators.parse_filter_eq",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Enum.parse_enum_key",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"LowParse.Spec.Enum.maybe_enum_key",
"FStar.Pervasives.Native.None",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input ==
(match parse p input with
| Some (x, consumed) ->
(match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None)
| _ -> None)) | [] | LowParse.Spec.Enum.parse_enum_key_eq | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k repr ->
e: LowParse.Spec.Enum.enum key repr ->
input: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.parse (LowParse.Spec.Enum.parse_enum_key p e) input ==
(match LowParse.Spec.Base.parse p input with
| FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x consumed) ->
(match LowParse.Spec.Enum.maybe_enum_key_of_repr e x with
| LowParse.Spec.Enum.Known #_ #_ #_ k -> FStar.Pervasives.Native.Some (k, consumed)
| _ -> FStar.Pervasives.Native.None)
<:
FStar.Pervasives.Native.option (LowParse.Spec.Enum.enum_key e *
LowParse.Spec.Base.consumed_length input)
| _ -> FStar.Pervasives.Native.None)) | {
"end_col": 88,
"end_line": 299,
"start_col": 2,
"start_line": 298
} |
Prims.Tot | val destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: (x: maybe_total_enum_key e -> Tot t))
(x: repr)
: Tot (y: t{eq y (f (maybe_total_enum_key_of_repr e x))}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x | val destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: (x: maybe_total_enum_key e -> Tot t))
(x: repr)
: Tot (y: t{eq y (f (maybe_total_enum_key_of_repr e x))})
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: (x: maybe_total_enum_key e -> Tot t))
(x: repr)
: Tot (y: t{eq y (f (maybe_total_enum_key_of_repr e x))}) = | false | null | false | destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Enum.maybe_enum_destr_t",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"LowParse.Spec.Enum.maybe_total_enum_key",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.total_of_maybe_enum_key",
"LowParse.Spec.Enum.maybe_total_enum_key_of_repr"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: (x: maybe_total_enum_key e -> Tot t))
(x: repr)
: Tot (y: t{eq y (f (maybe_total_enum_key_of_repr e x))}) | [] | LowParse.Spec.Enum.destr_maybe_total_enum_repr | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
e: LowParse.Spec.Enum.total_enum key repr ->
destr: LowParse.Spec.Enum.maybe_enum_destr_t t e ->
eq: (_: t -> _: t -> Prims.GTot Type0) ->
ift: LowParse.Spec.Enum.if_combinator t eq ->
eq_refl: LowParse.Spec.Enum.r_reflexive_t t eq ->
eq_trans: LowParse.Spec.Enum.r_transitive_t t eq ->
f: (x: LowParse.Spec.Enum.maybe_total_enum_key e -> t) ->
x: repr
-> y: t{eq y (f (LowParse.Spec.Enum.maybe_total_enum_key_of_repr e x))} | {
"end_col": 76,
"end_line": 868,
"start_col": 2,
"start_line": 868
} |
Prims.Pure | val enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e) (requires (Cons? e)) (ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e | val enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e) (requires (Cons? e)) (ensures (fun _ -> True))
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e) (requires (Cons? e)) (ensures (fun _ -> True)) = | false | null | false | fun
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
->
[@@ inline_let ]let _ = r_reflexive_t_elim _ _ eq_refl in
[@@ inline_let ]let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e': list (key * repr) {e' == e}) ->
match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) ->
(([@@ inline_let ]let f':(enum_key (enum_tail' e) -> Tot t) =
(fun (x': enum_key (enum_tail' e)) ->
[@@ inline_let ]let x_:enum_key e = (x' <: key) in
f x_)
in
[@@ inline_let ]let y:t =
ift ((k <: key) = x)
(fun h -> f k)
(fun h ->
[@@ inline_let ]let x':enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y)
<:
(y: t{eq y (f x)})))) e | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_destr_t",
"LowParse.Spec.Enum.enum_tail'",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.enum_key",
"Prims.op_Equality",
"LowParse.Spec.Combinators.cond_true",
"LowParse.Spec.Combinators.cond_false",
"Prims.unit",
"LowParse.Spec.Enum.r_transitive_t_elim",
"LowParse.Spec.Enum.r_reflexive_t_elim",
"Prims.b2t",
"Prims.uu___is_Cons",
"Prims.l_True"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e)) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e) (requires (Cons? e)) (ensures (fun _ -> True)) | [] | LowParse.Spec.Enum.enum_destr_cons | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: Type ->
e: LowParse.Spec.Enum.enum key repr ->
g: LowParse.Spec.Enum.enum_destr_t t (LowParse.Spec.Enum.enum_tail' e)
-> Prims.Pure (LowParse.Spec.Enum.enum_destr_t t e) | {
"end_col": 5,
"end_line": 651,
"start_col": 2,
"start_line": 623
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a | let list_hd (#t: Type) (l: list t {Cons? l}) = | false | null | false | match l with | a :: _ -> a | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.list",
"Prims.b2t",
"Prims.uu___is_Cons"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val list_hd : l: Prims.list t {Cons? l} -> t | [] | LowParse.Spec.Enum.list_hd | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l: Prims.list t {Cons? l} -> t | {
"end_col": 15,
"end_line": 897,
"start_col": 2,
"start_line": 896
} |
|
Prims.Tot | val enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(f: enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons e f | val enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(f: enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(f: enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e) = | false | null | false | enum_repr_of_key_cons e f | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.unit",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.enum_repr_of_key'_t",
"LowParse.Spec.Enum.enum_tail'",
"LowParse.Spec.Enum.enum_repr_of_key_cons"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e
inline_for_extraction
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e)) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(f: enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e) | [] | LowParse.Spec.Enum.enum_repr_of_key_cons' | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
key: Prims.eqtype ->
repr: Prims.eqtype ->
e: LowParse.Spec.Enum.enum key repr ->
u494: u496: Prims.unit{Cons? e} ->
f: LowParse.Spec.Enum.enum_repr_of_key'_t (LowParse.Spec.Enum.enum_tail' e)
-> LowParse.Spec.Enum.enum_repr_of_key'_t e | {
"end_col": 27,
"end_line": 1239,
"start_col": 2,
"start_line": 1239
} |
Prims.Tot | val mk_maybe_enum_destr (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Tot (maybe_enum_destr_t t e) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ()) | val mk_maybe_enum_destr (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Tot (maybe_enum_destr_t t e)
let mk_maybe_enum_destr (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Tot (maybe_enum_destr_t t e) = | false | null | false | maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ()) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_destr_t_intro",
"LowParse.Spec.Enum.mk_maybe_enum_destr'",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.maybe_enum_destr_t"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_maybe_enum_destr (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Tot (maybe_enum_destr_t t e) | [] | LowParse.Spec.Enum.mk_maybe_enum_destr | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | t: Type -> e: LowParse.Spec.Enum.enum key repr -> LowParse.Spec.Enum.maybe_enum_destr_t t e | {
"end_col": 65,
"end_line": 1003,
"start_col": 2,
"start_line": 1003
} |
FStar.Pervasives.Lemma | val list_rev_map (#t1 #t2: Type) (f: (t1 -> Tot t2)) (l: list t1)
: Lemma (L.rev (L.map f l) == L.map f (L.rev l)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a] | val list_rev_map (#t1 #t2: Type) (f: (t1 -> Tot t2)) (l: list t1)
: Lemma (L.rev (L.map f l) == L.map f (L.rev l))
let rec list_rev_map (#t1 #t2: Type) (f: (t1 -> Tot t2)) (l: list t1)
: Lemma (L.rev (L.map f l) == L.map f (L.rev l)) = | false | null | true | match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a] | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"Prims.list",
"FStar.List.Tot.Properties.map_append",
"FStar.List.Tot.Base.rev",
"Prims.Cons",
"Prims.Nil",
"Prims.unit",
"LowParse.Spec.Enum.list_rev_map",
"LowParse.Spec.Enum.list_rev_cons",
"FStar.List.Tot.Base.map",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val list_rev_map (#t1 #t2: Type) (f: (t1 -> Tot t2)) (l: list t1)
: Lemma (L.rev (L.map f l) == L.map f (L.rev l)) | [
"recursion"
] | LowParse.Spec.Enum.list_rev_map | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | f: (_: t1 -> t2) -> l: Prims.list t1
-> FStar.Pervasives.Lemma
(ensures
FStar.List.Tot.Base.rev (FStar.List.Tot.Base.map f l) ==
FStar.List.Tot.Base.map f (FStar.List.Tot.Base.rev l)) | {
"end_col": 32,
"end_line": 957,
"start_col": 2,
"start_line": 951
} |
Prims.Tot | val forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: (maybe_enum_key e -> GTot Type0))
(f_known:
squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x))
(list_map fst e)))
(f_unknown:
(x: value -> Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))))
: Tot (squash (forall (x: maybe_enum_key e). f x)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g | val forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: (maybe_enum_key e -> GTot Type0))
(f_known:
squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x))
(list_map fst e)))
(f_unknown:
(x: value -> Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))))
: Tot (squash (forall (x: maybe_enum_key e). f x))
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: (maybe_enum_key e -> GTot Type0))
(f_known:
squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x))
(list_map fst e)))
(f_unknown:
(x: value -> Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))))
: Tot (squash (forall (x: maybe_enum_key e). f x)) = | false | null | true | let g (x: maybe_enum_key e) : Lemma (f x) =
let u:squash (f x) =
destruct_maybe_enum_key e
(fun y -> squash (f y))
(fun x' u ->
list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x))
(list_map fst e))
(fun x' u -> f_unknown x')
x
in
assert (f x)
in
Classical.forall_intro g | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.squash",
"LowParse.Spec.Enum.list_forallp",
"Prims.l_and",
"Prims.b2t",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.fst",
"LowParse.Spec.Enum.Known",
"Prims.l_imp",
"Prims.eq2",
"Prims.bool",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.Unknown",
"FStar.Classical.forall_intro",
"Prims.unit",
"Prims.l_True",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims._assert",
"LowParse.Spec.Enum.destruct_maybe_enum_key",
"LowParse.Spec.Enum.list_forallp_mem",
"Prims.l_Forall"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
)) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: (maybe_enum_key e -> GTot Type0))
(f_known:
squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x))
(list_map fst e)))
(f_unknown:
(x: value -> Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))))
: Tot (squash (forall (x: maybe_enum_key e). f x)) | [] | LowParse.Spec.Enum.forall_maybe_enum_key | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
e: LowParse.Spec.Enum.enum key value ->
f: (_: LowParse.Spec.Enum.maybe_enum_key e -> Prims.GTot Type0) ->
f_known:
Prims.squash (LowParse.Spec.Enum.list_forallp (fun x ->
LowParse.Spec.Enum.list_mem x
(LowParse.Spec.Enum.list_map FStar.Pervasives.Native.fst e) /\
f (LowParse.Spec.Enum.Known x))
(LowParse.Spec.Enum.list_map FStar.Pervasives.Native.fst e)) ->
f_unknown:
(x: value
-> Prims.squash (LowParse.Spec.Enum.list_mem x
(LowParse.Spec.Enum.list_map FStar.Pervasives.Native.snd e) ==
false ==>
f (LowParse.Spec.Enum.Unknown x)))
-> Prims.squash (forall (x: LowParse.Spec.Enum.maybe_enum_key e). f x) | {
"end_col": 26,
"end_line": 1204,
"start_col": 1,
"start_line": 1191
} |
Prims.Tot | val maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (maybe_enum_key_of_repr'_t e) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (maybe_enum_key_of_repr'_t e)
= maybe_enum_key_of_repr'_t_cons_nil e | val maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (maybe_enum_key_of_repr'_t e)
let maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (maybe_enum_key_of_repr'_t e) = | false | null | false | maybe_enum_key_of_repr'_t_cons_nil e | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.unit",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"Prims.uu___is_Nil",
"LowParse.Spec.Enum.enum_tail'",
"LowParse.Spec.Enum.maybe_enum_key_of_repr'_t_cons_nil",
"LowParse.Spec.Enum.maybe_enum_key_of_repr'_t"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e
inline_for_extraction
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons e f
inline_for_extraction
let enum_repr_of_key_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun (x: enum_key e) ->
(r <: (r: enum_repr e { enum_repr_of_key e x == r } ))))
e
inline_for_extraction
let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons_nil e
let enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma
(requires (e == l1 `L.append` (kr :: l2)))
(ensures (list_mem (fst kr) (list_map fst e) /\ enum_repr_of_key e (fst kr) == snd kr /\ list_mem (snd kr) (list_map snd e) /\ enum_key_of_repr e (snd kr) == fst kr))
= L.map_append fst l1 (kr :: l2);
L.noRepeats_append_elim (L.map fst l1) (L.map fst (kr :: l2));
L.assoc_mem (fst kr) l1;
L.assoc_mem (fst kr) e;
L.assoc_append_elim_l (fst kr) l1 (kr :: l2);
enum_key_of_repr_of_key e (fst kr)
let maybe_enum_key_of_repr'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: repr) ->
Tot (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } )
#push-options "--z3rlimit 32"
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun x -> ((
if r = x
then Known k
else Unknown x
) <: (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } ))))
e
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } ) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (maybe_enum_key_of_repr'_t e) | [] | LowParse.Spec.Enum.maybe_enum_key_of_repr'_t_cons_nil' | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
key: Prims.eqtype ->
repr: Prims.eqtype ->
e: LowParse.Spec.Enum.enum key repr ->
u1: Prims.unit{Cons? e} ->
u2: Prims.unit{Nil? (LowParse.Spec.Enum.enum_tail' e)}
-> LowParse.Spec.Enum.maybe_enum_key_of_repr'_t e | {
"end_col": 38,
"end_line": 1312,
"start_col": 2,
"start_line": 1312
} |
Prims.Pure | val enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f: enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e) (requires (Cons? e)) (ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e | val enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f: enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e) (requires (Cons? e)) (ensures (fun _ -> True))
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f: enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e) (requires (Cons? e)) (ensures (fun _ -> True)) = | false | null | false | (fun (e': list (key * repr) {e' == e}) ->
match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) ->
(if k = x then (r <: repr) else (f (x <: key) <: repr))
<:
(r: enum_repr e {enum_repr_of_key e x == r}))) e | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_repr_of_key'_t",
"LowParse.Spec.Enum.enum_tail'",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.enum_key",
"Prims.op_Equality",
"Prims.bool",
"LowParse.Spec.Enum.enum_repr",
"Prims.eq2",
"LowParse.Spec.Enum.enum_repr_of_key",
"Prims.b2t",
"Prims.uu___is_Cons",
"Prims.l_True"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e)) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f: enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e) (requires (Cons? e)) (ensures (fun _ -> True)) | [] | LowParse.Spec.Enum.enum_repr_of_key_cons | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
e: LowParse.Spec.Enum.enum key repr ->
f: LowParse.Spec.Enum.enum_repr_of_key'_t (LowParse.Spec.Enum.enum_tail' e)
-> Prims.Pure (LowParse.Spec.Enum.enum_repr_of_key'_t e) | {
"end_col": 6,
"end_line": 1230,
"start_col": 2,
"start_line": 1223
} |
FStar.Pervasives.Lemma | val enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma (requires (e == l1 `L.append` (kr :: l2)))
(ensures
(list_mem (fst kr) (list_map fst e) /\ enum_repr_of_key e (fst kr) == snd kr /\
list_mem (snd kr) (list_map snd e) /\ enum_key_of_repr e (snd kr) == fst kr)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma
(requires (e == l1 `L.append` (kr :: l2)))
(ensures (list_mem (fst kr) (list_map fst e) /\ enum_repr_of_key e (fst kr) == snd kr /\ list_mem (snd kr) (list_map snd e) /\ enum_key_of_repr e (snd kr) == fst kr))
= L.map_append fst l1 (kr :: l2);
L.noRepeats_append_elim (L.map fst l1) (L.map fst (kr :: l2));
L.assoc_mem (fst kr) l1;
L.assoc_mem (fst kr) e;
L.assoc_append_elim_l (fst kr) l1 (kr :: l2);
enum_key_of_repr_of_key e (fst kr) | val enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma (requires (e == l1 `L.append` (kr :: l2)))
(ensures
(list_mem (fst kr) (list_map fst e) /\ enum_repr_of_key e (fst kr) == snd kr /\
list_mem (snd kr) (list_map snd e) /\ enum_key_of_repr e (snd kr) == fst kr))
let enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma (requires (e == l1 `L.append` (kr :: l2)))
(ensures
(list_mem (fst kr) (list_map fst e) /\ enum_repr_of_key e (fst kr) == snd kr /\
list_mem (snd kr) (list_map snd e) /\ enum_key_of_repr e (snd kr) == fst kr)) = | false | null | true | L.map_append fst l1 (kr :: l2);
L.noRepeats_append_elim (L.map fst l1) (L.map fst (kr :: l2));
L.assoc_mem (fst kr) l1;
L.assoc_mem (fst kr) e;
L.assoc_append_elim_l (fst kr) l1 (kr :: l2);
enum_key_of_repr_of_key e (fst kr) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.enum_key_of_repr_of_key",
"FStar.Pervasives.Native.fst",
"Prims.unit",
"FStar.List.Tot.Properties.assoc_append_elim_l",
"Prims.Cons",
"FStar.List.Tot.Properties.assoc_mem",
"FStar.List.Tot.Properties.noRepeats_append_elim",
"FStar.List.Tot.Base.map",
"FStar.List.Tot.Properties.map_append",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"LowParse.Spec.Enum.enum_repr_of_key",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.enum_key_of_repr",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e
inline_for_extraction
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons e f
inline_for_extraction
let enum_repr_of_key_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun (x: enum_key e) ->
(r <: (r: enum_repr e { enum_repr_of_key e x == r } ))))
e
inline_for_extraction
let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons_nil e
let enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma
(requires (e == l1 `L.append` (kr :: l2))) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma (requires (e == l1 `L.append` (kr :: l2)))
(ensures
(list_mem (fst kr) (list_map fst e) /\ enum_repr_of_key e (fst kr) == snd kr /\
list_mem (snd kr) (list_map snd e) /\ enum_key_of_repr e (snd kr) == fst kr)) | [] | LowParse.Spec.Enum.enum_repr_of_key_append_cons | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
e: LowParse.Spec.Enum.enum key repr ->
l1: Prims.list (key * repr) ->
kr: (key * repr) ->
l2: Prims.list (key * repr)
-> FStar.Pervasives.Lemma (requires e == l1 @ kr :: l2)
(ensures
LowParse.Spec.Enum.list_mem (FStar.Pervasives.Native.fst kr)
(LowParse.Spec.Enum.list_map FStar.Pervasives.Native.fst e) /\
LowParse.Spec.Enum.enum_repr_of_key e (FStar.Pervasives.Native.fst kr) ==
FStar.Pervasives.Native.snd kr /\
LowParse.Spec.Enum.list_mem (FStar.Pervasives.Native.snd kr)
(LowParse.Spec.Enum.list_map FStar.Pervasives.Native.snd e) /\
LowParse.Spec.Enum.enum_key_of_repr e (FStar.Pervasives.Native.snd kr) ==
FStar.Pervasives.Native.fst kr) | {
"end_col": 36,
"end_line": 1277,
"start_col": 2,
"start_line": 1272
} |
Prims.Tot | val maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )) | val maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1) = | false | null | false | fun
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: (maybe_enum_key e -> Tot t))
->
[@@ inline_let ]let _ = r_reflexive_t_elim _ _ eq_refl in
[@@ inline_let ]let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr{maybe_enum_key_of_repr_not_in e l1 x}) ->
((L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x))
<:
(y: t{eq y (f (maybe_enum_key_of_repr e x))})) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Nil",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.List.Tot.Base.rev",
"Prims.Nil",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.maybe_enum_key_of_repr_not_in",
"LowParse.Spec.Enum.Unknown",
"Prims.unit",
"FStar.List.Tot.Properties.rev_mem",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.list_rev_map",
"FStar.List.Tot.Properties.append_l_nil",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"LowParse.Spec.Enum.r_transitive_t_elim",
"LowParse.Spec.Enum.r_reflexive_t_elim",
"LowParse.Spec.Enum.maybe_enum_destr_t'"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) [])) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1) | [] | LowParse.Spec.Enum.maybe_enum_destr_nil | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: Type ->
e: LowParse.Spec.Enum.enum key repr ->
l1: Prims.list (key * repr) ->
l2: Prims.list (key * repr) ->
u1: Prims.squash (Nil? l2 /\ e == FStar.List.Tot.Base.rev l1 @ [])
-> LowParse.Spec.Enum.maybe_enum_destr_t' t e l1 l2 u1 | {
"end_col": 57,
"end_line": 978,
"start_col": 2,
"start_line": 968
} |
Prims.Pure | val maybe_enum_key_of_repr'_t_cons
(#key #repr: eqtype)
(e: enum key repr)
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Pure (maybe_enum_key_of_repr'_t e) (requires (Cons? e)) (ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let maybe_enum_key_of_repr'_t_cons
(#key #repr: eqtype)
(e: enum key repr )
(g : maybe_enum_key_of_repr'_t (enum_tail' e))
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun x -> ((
if r = x
then Known k
else
let y : maybe_enum_key (enum_tail' e) = g x in
match y with
| Known k' -> Known (k' <: key)
| Unknown x' -> Unknown x
) <: (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } ))))
e | val maybe_enum_key_of_repr'_t_cons
(#key #repr: eqtype)
(e: enum key repr)
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Pure (maybe_enum_key_of_repr'_t e) (requires (Cons? e)) (ensures (fun _ -> True))
let maybe_enum_key_of_repr'_t_cons
(#key #repr: eqtype)
(e: enum key repr)
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Pure (maybe_enum_key_of_repr'_t e) (requires (Cons? e)) (ensures (fun _ -> True)) = | false | null | false | (fun (e': list (key * repr) {e' == e}) ->
match e' with
| (k, r) :: _ ->
(fun x ->
((if r = x
then Known k
else
let y:maybe_enum_key (enum_tail' e) = g x in
match y with
| Known k' -> Known (k' <: key)
| Unknown x' -> Unknown x)
<:
(k: maybe_enum_key e {k == maybe_enum_key_of_repr e x})))) e | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key_of_repr'_t",
"LowParse.Spec.Enum.enum_tail'",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.op_Equality",
"LowParse.Spec.Enum.Known",
"Prims.bool",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.unknown_enum_repr",
"LowParse.Spec.Enum.Unknown",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.eq2",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"Prims.b2t",
"Prims.uu___is_Cons",
"Prims.l_True"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e
inline_for_extraction
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons e f
inline_for_extraction
let enum_repr_of_key_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun (x: enum_key e) ->
(r <: (r: enum_repr e { enum_repr_of_key e x == r } ))))
e
inline_for_extraction
let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons_nil e
let enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma
(requires (e == l1 `L.append` (kr :: l2)))
(ensures (list_mem (fst kr) (list_map fst e) /\ enum_repr_of_key e (fst kr) == snd kr /\ list_mem (snd kr) (list_map snd e) /\ enum_key_of_repr e (snd kr) == fst kr))
= L.map_append fst l1 (kr :: l2);
L.noRepeats_append_elim (L.map fst l1) (L.map fst (kr :: l2));
L.assoc_mem (fst kr) l1;
L.assoc_mem (fst kr) e;
L.assoc_append_elim_l (fst kr) l1 (kr :: l2);
enum_key_of_repr_of_key e (fst kr)
let maybe_enum_key_of_repr'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: repr) ->
Tot (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } )
#push-options "--z3rlimit 32"
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun x -> ((
if r = x
then Known k
else Unknown x
) <: (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } ))))
e
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (maybe_enum_key_of_repr'_t e)
= maybe_enum_key_of_repr'_t_cons_nil e
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons
(#key #repr: eqtype)
(e: enum key repr )
(g : maybe_enum_key_of_repr'_t (enum_tail' e))
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e)) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val maybe_enum_key_of_repr'_t_cons
(#key #repr: eqtype)
(e: enum key repr)
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Pure (maybe_enum_key_of_repr'_t e) (requires (Cons? e)) (ensures (fun _ -> True)) | [] | LowParse.Spec.Enum.maybe_enum_key_of_repr'_t_cons | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
e: LowParse.Spec.Enum.enum key repr ->
g: LowParse.Spec.Enum.maybe_enum_key_of_repr'_t (LowParse.Spec.Enum.enum_tail' e)
-> Prims.Pure (LowParse.Spec.Enum.maybe_enum_key_of_repr'_t e) | {
"end_col": 7,
"end_line": 1333,
"start_col": 2,
"start_line": 1322
} |
Prims.Tot | val maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f | val maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e) = | false | null | false | f | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_destr_t'",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.maybe_enum_destr_t"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ()) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e) | [] | LowParse.Spec.Enum.maybe_enum_destr_t_intro | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: Type ->
e: LowParse.Spec.Enum.enum key repr ->
f: LowParse.Spec.Enum.maybe_enum_destr_t' t e [] e ()
-> LowParse.Spec.Enum.maybe_enum_destr_t t e | {
"end_col": 3,
"end_line": 877,
"start_col": 2,
"start_line": 877
} |
Prims.Tot | val enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } ) | val enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = | false | null | false | (r: repr{list_mem r (list_map snd e)}) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.b2t",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.snd"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype | [] | LowParse.Spec.Enum.enum_repr | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.enum key repr -> Prims.eqtype | {
"end_col": 111,
"end_line": 41,
"start_col": 69,
"start_line": 41
} |
Prims.Tot | val enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } ) | val enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = | false | null | false | (s: key{list_mem s (list_map fst e)}) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.b2t",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.fst"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype | [] | LowParse.Spec.Enum.enum_key | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.enum key repr -> Prims.eqtype | {
"end_col": 109,
"end_line": 32,
"start_col": 68,
"start_line": 32
} |
Prims.GTot | val parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr{parse_enum_key_cond e r == true})
: GTot (enum_key e) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r | val parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr{parse_enum_key_cond e r == true})
: GTot (enum_key e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr{parse_enum_key_cond e r == true})
: GTot (enum_key e) = | false | null | false | enum_key_of_repr e r | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"sometrivial"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.eq2",
"Prims.bool",
"LowParse.Spec.Enum.parse_enum_key_cond",
"LowParse.Spec.Enum.enum_key_of_repr",
"LowParse.Spec.Enum.enum_key"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } ) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr{parse_enum_key_cond e r == true})
: GTot (enum_key e) | [] | LowParse.Spec.Enum.parse_enum_key_synth | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.enum key repr -> r: repr{LowParse.Spec.Enum.parse_enum_key_cond e r == true}
-> Prims.GTot (LowParse.Spec.Enum.enum_key e) | {
"end_col": 22,
"end_line": 153,
"start_col": 2,
"start_line": 153
} |
FStar.Pervasives.Lemma | val map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma (list_map flip (list_map flip l) == l) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q | val map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma (list_map flip (list_map flip l) == l)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma (list_map flip (list_map flip l) == l) = | false | null | true | match l with
| [] -> ()
| _ :: q -> map_flip_flip q | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.map_flip_flip",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"LowParse.Spec.Enum.list_map",
"LowParse.Spec.Enum.flip",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma (list_map flip (list_map flip l) == l) | [
"recursion"
] | LowParse.Spec.Enum.map_flip_flip | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l: Prims.list (a * b)
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Enum.list_map LowParse.Spec.Enum.flip
(LowParse.Spec.Enum.list_map LowParse.Spec.Enum.flip l) ==
l) | {
"end_col": 29,
"end_line": 49,
"start_col": 2,
"start_line": 47
} |
Prims.Tot | val maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g:
(maybe_enum_destr_t' t
e
(list_hd l2 :: l1)
(list_tl l2)
(list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )) | val maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g:
(maybe_enum_destr_t' t
e
(list_hd l2 :: l1)
(list_tl l2)
(list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g:
(maybe_enum_destr_t' t
e
(list_hd l2 :: l1)
(list_tl l2)
(list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1) = | false | null | false | fun
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: (maybe_enum_key e -> Tot t))
->
[@@ inline_let ]let _ = r_reflexive_t_elim _ _ eq_refl in
[@@ inline_let ]let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| k, r ->
[@@ inline_let ]let _:squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@@ inline_let ]let _:squash (maybe_enum_key_of_repr e r == Known k) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr{maybe_enum_key_of_repr_not_in e l1 x}) ->
((ift (x = r) (fun h -> f (Known k)) (fun h -> g eq ift eq_refl eq_trans f x))
<:
(y: t{eq y (f (maybe_enum_key_of_repr e x))})) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Cons",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.List.Tot.Base.rev",
"LowParse.Spec.Enum.maybe_enum_destr_t'",
"Prims.Cons",
"LowParse.Spec.Enum.list_hd",
"LowParse.Spec.Enum.list_tl",
"LowParse.Spec.Enum.list_append_rev_cons",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.maybe_enum_key_of_repr_not_in",
"Prims.op_Equality",
"LowParse.Spec.Combinators.cond_true",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Combinators.cond_false",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"Prims.unit",
"LowParse.Spec.Enum.assoc_append_flip_l_intro",
"FStar.List.Tot.Properties.map_append",
"FStar.Pervasives.Native.snd",
"FStar.List.Tot.Properties.append_mem",
"FStar.List.Tot.Base.map",
"FStar.List.Tot.Base.mem",
"FStar.Pervasives.Native.fst",
"LowParse.Spec.Enum.r_transitive_t_elim",
"LowParse.Spec.Enum.r_reflexive_t_elim"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g:
(maybe_enum_destr_t' t
e
(list_hd l2 :: l1)
(list_tl l2)
(list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1) | [] | LowParse.Spec.Enum.maybe_enum_destr_cons | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: Type ->
e: LowParse.Spec.Enum.enum key repr ->
l1: Prims.list (key * repr) ->
l2: Prims.list (key * repr) ->
u1: Prims.squash (Cons? l2 /\ e == FStar.List.Tot.Base.rev l1 @ l2) ->
g:
LowParse.Spec.Enum.maybe_enum_destr_t' t
e
(LowParse.Spec.Enum.list_hd l2 :: l1)
(LowParse.Spec.Enum.list_tl l2)
(LowParse.Spec.Enum.list_append_rev_cons l1
(LowParse.Spec.Enum.list_hd l2)
(LowParse.Spec.Enum.list_tl l2))
-> LowParse.Spec.Enum.maybe_enum_destr_t' t e l1 l2 u1 | {
"end_col": 57,
"end_line": 943,
"start_col": 2,
"start_line": 918
} |
FStar.Pervasives.Lemma | val map_fst_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map fst (list_map flip l) == list_map snd l) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q | val map_fst_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map fst (list_map flip l) == list_map snd l)
let rec map_fst_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map fst (list_map flip l) == list_map snd l) = | false | null | true | match l with
| [] -> ()
| _ :: q -> map_fst_flip q | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.map_fst_flip",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.l_or",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.snd",
"FStar.Pervasives.Native.fst",
"LowParse.Spec.Enum.list_map",
"LowParse.Spec.Enum.flip",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map_fst_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map fst (list_map flip l) == list_map snd l) | [
"recursion"
] | LowParse.Spec.Enum.map_fst_flip | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l: Prims.list (a * b)
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Enum.list_map FStar.Pervasives.Native.fst
(LowParse.Spec.Enum.list_map LowParse.Spec.Enum.flip l) ==
LowParse.Spec.Enum.list_map FStar.Pervasives.Native.snd l) | {
"end_col": 28,
"end_line": 55,
"start_col": 2,
"start_line": 53
} |
FStar.Pervasives.Lemma | val enum_key_of_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Lemma (enum_key_of_repr e (enum_repr_of_key e k) == k) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k | val enum_key_of_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Lemma (enum_key_of_repr e (enum_repr_of_key e k) == k)
let enum_key_of_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Lemma (enum_key_of_repr e (enum_repr_of_key e k) == k) = | false | null | true | assoc_flip_intro e (enum_repr_of_key e k) k | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.assoc_flip_intro",
"LowParse.Spec.Enum.enum_repr_of_key",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"LowParse.Spec.Enum.enum_key_of_repr",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_key_of_repr_of_key (#key #repr: eqtype) (e: enum key repr) (k: enum_key e)
: Lemma (enum_key_of_repr e (enum_repr_of_key e k) == k) | [] | LowParse.Spec.Enum.enum_key_of_repr_of_key | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.enum key repr -> k: LowParse.Spec.Enum.enum_key e
-> FStar.Pervasives.Lemma
(ensures LowParse.Spec.Enum.enum_key_of_repr e (LowParse.Spec.Enum.enum_repr_of_key e k) == k) | {
"end_col": 45,
"end_line": 196,
"start_col": 2,
"start_line": 196
} |
Prims.GTot | val is_total_enum (#key #repr: eqtype) (l: list (key * repr)) : GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l) | val is_total_enum (#key #repr: eqtype) (l: list (key * repr)) : GTot Type0
let is_total_enum (#key #repr: eqtype) (l: list (key * repr)) : GTot Type0 = | false | null | false | forall (k: key). {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"sometrivial"
] | [
"Prims.eqtype",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.l_Forall",
"Prims.b2t",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.fst"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val is_total_enum (#key #repr: eqtype) (l: list (key * repr)) : GTot Type0 | [] | LowParse.Spec.Enum.is_total_enum | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l: Prims.list (key * repr) -> Prims.GTot Type0 | {
"end_col": 88,
"end_line": 333,
"start_col": 2,
"start_line": 333
} |
Prims.GTot | val r_reflexive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x | val r_reflexive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0
let r_reflexive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0 = | false | null | false | forall (x: t). {:pattern (r x x)} r x x | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"sometrivial"
] | [
"Prims.l_Forall"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0)) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val r_reflexive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0 | [] | LowParse.Spec.Enum.r_reflexive_prop | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | t: Type -> r: (_: t -> _: t -> Prims.GTot Type0) -> Prims.GTot Type0 | {
"end_col": 42,
"end_line": 464,
"start_col": 2,
"start_line": 464
} |
Prims.Tot | val dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g:
(dep_maybe_enum_destr_t' e
v
(list_hd l2 :: l1)
(list_tl l2)
(list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } )) | val dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g:
(dep_maybe_enum_destr_t' e
v
(list_hd l2 :: l1)
(list_tl l2)
(list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g:
(dep_maybe_enum_destr_t' e
v
(list_hd l2 :: l1)
(list_tl l2)
(list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) = | false | null | false | fun
(v_eq: (k: maybe_enum_key e -> v k -> v k -> GTot Type0))
(v_if: (k: maybe_enum_key e -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: (k: maybe_enum_key e -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: (k: maybe_enum_key e -> Tot (r_transitive_t _ (v_eq k))))
(f: (k: maybe_enum_key e -> Tot (v k)))
->
match list_hd l2 with
| k, r ->
[@@ inline_let ]let _:squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@@ inline_let ]let _:squash (maybe_enum_key_of_repr e r == Known k) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr{maybe_enum_key_of_repr_not_in e l1 x}) ->
[@@ inline_let ]let y:v (maybe_enum_key_of_repr e x) =
v_if (maybe_enum_key_of_repr e x)
(x = r)
(fun h -> f (Known k))
(fun h -> g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@@ inline_let ]let _:squash (v_eq (maybe_enum_key_of_repr e x)
y
(f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else
v_eq_trans (maybe_enum_key_of_repr e x)
y
(g v_eq v_if v_eq_refl v_eq_trans f x)
(f (maybe_enum_key_of_repr e x))
in
(y
<:
(y:
v (maybe_enum_key_of_repr e x)
{v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))})) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Cons",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.List.Tot.Base.rev",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t'",
"Prims.Cons",
"LowParse.Spec.Enum.list_hd",
"LowParse.Spec.Enum.list_tl",
"LowParse.Spec.Enum.list_append_rev_cons",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"LowParse.Spec.Enum.maybe_enum_key_of_repr_not_in",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"Prims.op_Equality",
"Prims.bool",
"LowParse.Spec.Combinators.cond_true",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Combinators.cond_false",
"Prims.unit",
"LowParse.Spec.Enum.assoc_append_flip_l_intro",
"FStar.List.Tot.Properties.map_append",
"FStar.Pervasives.Native.snd",
"FStar.List.Tot.Properties.append_mem",
"FStar.List.Tot.Base.map",
"FStar.List.Tot.Base.mem",
"FStar.Pervasives.Native.fst"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g:
(dep_maybe_enum_destr_t' e
v
(list_hd l2 :: l1)
(list_tl l2)
(list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) | [] | LowParse.Spec.Enum.dep_maybe_enum_destr_cons | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
e: LowParse.Spec.Enum.enum key repr ->
v: (_: LowParse.Spec.Enum.maybe_enum_key e -> Type) ->
l1: Prims.list (key * repr) ->
l2: Prims.list (key * repr) ->
u1: Prims.squash (Cons? l2 /\ e == FStar.List.Tot.Base.rev l1 @ l2) ->
g:
LowParse.Spec.Enum.dep_maybe_enum_destr_t' e
v
(LowParse.Spec.Enum.list_hd l2 :: l1)
(LowParse.Spec.Enum.list_tl l2)
(LowParse.Spec.Enum.list_append_rev_cons l1
(LowParse.Spec.Enum.list_hd l2)
(LowParse.Spec.Enum.list_tl l2))
-> LowParse.Spec.Enum.dep_maybe_enum_destr_t' e v l1 l2 u1 | {
"end_col": 120,
"end_line": 1095,
"start_col": 2,
"start_line": 1056
} |
Prims.GTot | val r_transitive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z | val r_transitive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0
let r_transitive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0 = | false | null | false | forall (x: t) (y: t) (z: t). {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"sometrivial"
] | [
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0)) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val r_transitive_prop (t: Type) (r: (t -> t -> GTot Type0)) : GTot Type0 | [] | LowParse.Spec.Enum.r_transitive_prop | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | t: Type -> r: (_: t -> _: t -> Prims.GTot Type0) -> Prims.GTot Type0 | {
"end_col": 76,
"end_line": 485,
"start_col": 2,
"start_line": 485
} |
FStar.Pervasives.Lemma | val map_snd_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map snd (list_map flip l) == list_map fst l) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q | val map_snd_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map snd (list_map flip l) == list_map fst l)
let rec map_snd_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map snd (list_map flip l) == list_map fst l) = | false | null | true | match l with
| [] -> ()
| _ :: q -> map_snd_flip q | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.map_snd_flip",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.l_or",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.list_map",
"LowParse.Spec.Enum.flip",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map_snd_flip (#a #b: Type) (l: list (a * b))
: Lemma (list_map snd (list_map flip l) == list_map fst l) | [
"recursion"
] | LowParse.Spec.Enum.map_snd_flip | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l: Prims.list (a * b)
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Enum.list_map FStar.Pervasives.Native.snd
(LowParse.Spec.Enum.list_map LowParse.Spec.Enum.flip l) ==
LowParse.Spec.Enum.list_map FStar.Pervasives.Native.fst l) | {
"end_col": 28,
"end_line": 61,
"start_col": 2,
"start_line": 59
} |
Prims.Tot | val enum_tail (#key #repr: eqtype) (e: enum key repr) : Tot (enum key repr) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e | val enum_tail (#key #repr: eqtype) (e: enum key repr) : Tot (enum key repr)
let enum_tail (#key #repr: eqtype) (e: enum key repr) : Tot (enum key repr) = | false | null | false | enum_tail' e | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_tail'"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_tail (#key #repr: eqtype) (e: enum key repr) : Tot (enum key repr) | [] | LowParse.Spec.Enum.enum_tail | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.enum key repr -> LowParse.Spec.Enum.enum key repr | {
"end_col": 14,
"end_line": 612,
"start_col": 2,
"start_line": 612
} |
Prims.Tot | val dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k': enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } )) | val dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k': enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k': enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v) = | false | null | false | match e with
| (k, _) :: _ ->
fun
(v_eq: (k: enum_key e -> v k -> v k -> GTot Type0))
(v_if: (k: enum_key e -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: (k: enum_key e -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: (k: enum_key e -> Tot (r_transitive_t _ (v_eq k))))
(f: (k: enum_key e -> Tot (v k)))
(k': enum_key e)
->
[@@ inline_let ]let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@@ inline_let ]let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@@ inline_let ]let y:v k' =
v_if k'
(k = k')
(fun _ ->
[@@ inline_let ]let y:v k' = f k in
y)
(fun _ ->
[@@ inline_let ]let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@@ inline_let ]let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0)
=
v_eq (k <: key)
in
[@@ inline_let ]let v'_if (k: enum_key (enum_tail e))
: Tot (if_combinator (v' k) (v'_eq k)) =
v_if (k <: key)
in
[@@ inline_let ]let v'_eq_refl (k: enum_key (enum_tail e))
: Tot (r_reflexive_t _ (v'_eq k)) =
v_eq_refl (k <: key)
in
[@@ inline_let ]let v'_eq_trans (k: enum_key (enum_tail e))
: Tot (r_transitive_t _ (v'_eq k)) =
v_eq_trans (k <: key)
in
[@@ inline_let ]let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@@ inline_let ]let k':key = k' in
[@@ inline_let ]let _ = assert (k' <> k) in
[@@ inline_let ]let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@@ inline_let ]let y:v' k' = destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k' in
y)
in
(y <: (y: v k' {v_eq k' y (f k')})) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.squash",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.dep_enum_destr",
"LowParse.Spec.Enum.enum_tail",
"Prims.list",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"Prims.op_Equality",
"LowParse.Spec.Combinators.cond_true",
"LowParse.Spec.Combinators.cond_false",
"Prims.unit",
"Prims._assert",
"FStar.List.Tot.Base.mem",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.fst",
"Prims.op_disEquality",
"LowParse.Spec.Enum.r_transitive_t_elim",
"LowParse.Spec.Enum.r_reflexive_t_elim"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key))) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k': enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v) | [] | LowParse.Spec.Enum.dep_enum_destr_cons | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
e: LowParse.Spec.Enum.enum key repr ->
u330: Prims.squash (Cons? e) ->
v: (_: LowParse.Spec.Enum.enum_key e -> Type) ->
destr: LowParse.Spec.Enum.dep_enum_destr (LowParse.Spec.Enum.enum_tail e) (fun k' -> v k')
-> LowParse.Spec.Enum.dep_enum_destr e v | {
"end_col": 42,
"end_line": 762,
"start_col": 2,
"start_line": 717
} |
Prims.GTot | val maybe_enum_key_of_repr_not_in
(#key #repr: eqtype)
(e: enum key repr)
(l: list (key * repr))
(x: repr)
: GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l))) | val maybe_enum_key_of_repr_not_in
(#key #repr: eqtype)
(e: enum key repr)
(l: list (key * repr))
(x: repr)
: GTot Type0
let maybe_enum_key_of_repr_not_in
(#key #repr: eqtype)
(e: enum key repr)
(l: list (key * repr))
(x: repr)
: GTot Type0 = | false | null | false | (~(L.mem x (L.map snd l))) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"sometrivial"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.l_not",
"Prims.b2t",
"FStar.List.Tot.Base.mem",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.snd"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val maybe_enum_key_of_repr_not_in
(#key #repr: eqtype)
(e: enum key repr)
(l: list (key * repr))
(x: repr)
: GTot Type0 | [] | LowParse.Spec.Enum.maybe_enum_key_of_repr_not_in | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.enum key repr -> l: Prims.list (key * repr) -> x: repr -> Prims.GTot Type0 | {
"end_col": 29,
"end_line": 792,
"start_col": 2,
"start_line": 792
} |
Prims.Tot | val serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
() | val serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e)) = | false | null | false | serialize_enum_key_synth_inverse e;
serialize_synth (parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
() | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Combinators.serialize_synth",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Enum.parse_enum_key_cond",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Spec.Enum.parse_enum_key_synth",
"LowParse.Spec.Combinators.serialize_filter",
"LowParse.Spec.Enum.serialize_enum_key_synth_recip",
"Prims.unit",
"LowParse.Spec.Enum.serialize_enum_key_synth_inverse",
"LowParse.Spec.Enum.parse_enum_key"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e)) | [] | LowParse.Spec.Enum.serialize_enum_key | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k repr ->
s: LowParse.Spec.Base.serializer p ->
e: LowParse.Spec.Enum.enum key repr
-> LowParse.Spec.Base.serializer (LowParse.Spec.Enum.parse_enum_key p e) | {
"end_col": 6,
"end_line": 225,
"start_col": 2,
"start_line": 219
} |
Prims.Tot | val maybe_enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: repr)
: Tot (maybe_enum_key e) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r | val maybe_enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: repr)
: Tot (maybe_enum_key e)
let maybe_enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: repr)
: Tot (maybe_enum_key e) = | false | null | false | if list_mem r (list_map snd e) then Known (enum_key_of_repr e r) else Unknown r | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Enum.enum_key_of_repr",
"Prims.bool",
"LowParse.Spec.Enum.Unknown",
"LowParse.Spec.Enum.maybe_enum_key"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val maybe_enum_key_of_repr (#key #repr: eqtype) (e: enum key repr) (r: repr)
: Tot (maybe_enum_key e) | [] | LowParse.Spec.Enum.maybe_enum_key_of_repr | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.enum key repr -> r: repr -> LowParse.Spec.Enum.maybe_enum_key e | {
"end_col": 16,
"end_line": 260,
"start_col": 2,
"start_line": 258
} |
Prims.Tot | val parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e) | val parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e)) = | false | null | false | p `parse_synth` (maybe_enum_key_of_repr e) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.maybe_enum_key_of_repr"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e)) | [] | LowParse.Spec.Enum.parse_maybe_enum_key | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.parser k repr -> e: LowParse.Spec.Enum.enum key repr
-> LowParse.Spec.Base.parser k (LowParse.Spec.Enum.maybe_enum_key e) | {
"end_col": 44,
"end_line": 268,
"start_col": 2,
"start_line": 268
} |
Prims.Tot | val serialize_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) () | val serialize_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
let serialize_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l)) = | false | null | false | serialize_synth (parse_enum_key p l)
(synth_total_enum_key l)
(serialize_enum_key p s l)
(synth_total_enum_key_recip l)
() | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Combinators.serialize_synth",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.parse_enum_key",
"LowParse.Spec.Enum.synth_total_enum_key",
"LowParse.Spec.Enum.serialize_enum_key",
"LowParse.Spec.Enum.synth_total_enum_key_recip",
"LowParse.Spec.Enum.parse_total_enum_key"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l)) | [] | LowParse.Spec.Enum.serialize_total_enum_key | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k repr ->
s: LowParse.Spec.Base.serializer p ->
l: LowParse.Spec.Enum.total_enum key repr
-> LowParse.Spec.Base.serializer (LowParse.Spec.Enum.parse_total_enum_key p l) | {
"end_col": 124,
"end_line": 372,
"start_col": 2,
"start_line": 372
} |
Prims.Tot | val repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr{maybe_total_enum_key_of_repr e r == k}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r | val repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr{maybe_total_enum_key_of_repr e r == k})
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr{maybe_total_enum_key_of_repr e r == k}) = | false | null | false | match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k';
enum_repr_of_key e k'
| TotalUnknown r -> r | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Enum.maybe_total_enum_key",
"LowParse.Spec.Enum.enum_repr_of_key",
"Prims.unit",
"LowParse.Spec.Enum.enum_key_of_repr_of_key",
"LowParse.Spec.Enum.unknown_enum_repr",
"Prims.eq2",
"LowParse.Spec.Enum.maybe_total_enum_key_of_repr"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr{maybe_total_enum_key_of_repr e r == k}) | [] | LowParse.Spec.Enum.repr_of_maybe_total_enum_key | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.total_enum key repr -> k: LowParse.Spec.Enum.maybe_total_enum_key e
-> r: repr{LowParse.Spec.Enum.maybe_total_enum_key_of_repr e r == k} | {
"end_col": 23,
"end_line": 404,
"start_col": 2,
"start_line": 400
} |
Prims.Tot | val maybe_total_enum_key_of_repr (#key #repr: eqtype) (e: total_enum key repr) (r: repr)
: Tot (maybe_total_enum_key e) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r | val maybe_total_enum_key_of_repr (#key #repr: eqtype) (e: total_enum key repr) (r: repr)
: Tot (maybe_total_enum_key e)
let maybe_total_enum_key_of_repr (#key #repr: eqtype) (e: total_enum key repr) (r: repr)
: Tot (maybe_total_enum_key e) = | false | null | false | if list_mem r (list_map snd e) then TotalKnown (enum_key_of_repr e r) else TotalUnknown r | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.TotalKnown",
"LowParse.Spec.Enum.enum_key_of_repr",
"Prims.bool",
"LowParse.Spec.Enum.TotalUnknown",
"LowParse.Spec.Enum.maybe_total_enum_key"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val maybe_total_enum_key_of_repr (#key #repr: eqtype) (e: total_enum key repr) (r: repr)
: Tot (maybe_total_enum_key e) | [] | LowParse.Spec.Enum.maybe_total_enum_key_of_repr | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.total_enum key repr -> r: repr -> LowParse.Spec.Enum.maybe_total_enum_key e | {
"end_col": 21,
"end_line": 385,
"start_col": 2,
"start_line": 383
} |
Prims.Tot | val maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r | val maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e) = | false | null | false | match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Enum.maybe_total_enum_key",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Enum.unknown_enum_repr",
"LowParse.Spec.Enum.Unknown",
"LowParse.Spec.Enum.maybe_enum_key"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e) | [] | LowParse.Spec.Enum.maybe_enum_key_of_total | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.total_enum key repr -> k: LowParse.Spec.Enum.maybe_total_enum_key e
-> LowParse.Spec.Enum.maybe_enum_key e | {
"end_col": 31,
"end_line": 423,
"start_col": 2,
"start_line": 421
} |
Prims.Tot | val parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e) | val parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e)) = | false | null | false | p `parse_synth` (maybe_total_enum_key_of_repr e) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Enum.total_enum",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Enum.maybe_total_enum_key",
"LowParse.Spec.Enum.maybe_total_enum_key_of_repr"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e)) | [] | LowParse.Spec.Enum.parse_maybe_total_enum_key | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.parser k repr -> e: LowParse.Spec.Enum.total_enum key repr
-> LowParse.Spec.Base.parser k (LowParse.Spec.Enum.maybe_total_enum_key e) | {
"end_col": 50,
"end_line": 393,
"start_col": 2,
"start_line": 393
} |
FStar.Pervasives.Lemma | val serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x | val serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x)) = | false | null | true | serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Combinators.serialize_synth_eq",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"LowParse.Spec.Enum.repr_of_maybe_enum_key",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.Enum.parse_maybe_enum_key",
"LowParse.Spec.Enum.serialize_maybe_enum_key",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x)) | [] | LowParse.Spec.Enum.serialize_maybe_enum_key_eq | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s: LowParse.Spec.Base.serializer p ->
e: LowParse.Spec.Enum.enum key repr ->
x: LowParse.Spec.Enum.maybe_enum_key e
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.serialize (LowParse.Spec.Enum.serialize_maybe_enum_key p s e) x ==
LowParse.Spec.Base.serialize s (LowParse.Spec.Enum.repr_of_maybe_enum_key e x)) | {
"end_col": 83,
"end_line": 330,
"start_col": 2,
"start_line": 330
} |
Prims.Tot | val default_if (t: Type) : Tot (if_combinator t (eq2 #t)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } ) | val default_if (t: Type) : Tot (if_combinator t (eq2 #t))
let default_if (t: Type) : Tot (if_combinator t (eq2 #t)) = | false | null | false | fun (cond: bool) (s_true: (cond_true cond -> Tot t)) (s_false: (cond_false cond -> Tot t)) ->
(if cond then s_true () else s_false ()) <: (y: t{y == (if cond then s_true () else s_false ())}) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.bool",
"LowParse.Spec.Combinators.cond_true",
"LowParse.Spec.Combinators.cond_false",
"Prims.eq2",
"LowParse.Spec.Enum.if_combinator"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val default_if (t: Type) : Tot (if_combinator t (eq2 #t)) | [] | LowParse.Spec.Enum.default_if | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | t: Type -> LowParse.Spec.Enum.if_combinator t Prims.eq2 | {
"end_col": 79,
"end_line": 522,
"start_col": 2,
"start_line": 516
} |
Prims.Tot | val enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail e)})
: Tot (enum_destr_t t e) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e | val enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail e)})
: Tot (enum_destr_t t e)
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail e)})
: Tot (enum_destr_t t e) = | false | null | false | enum_destr_cons_nil t e | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.unit",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"Prims.uu___is_Nil",
"LowParse.Spec.Enum.enum_tail",
"LowParse.Spec.Enum.enum_destr_cons_nil",
"LowParse.Spec.Enum.enum_destr_t"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } ) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail e)})
: Tot (enum_destr_t t e) | [] | LowParse.Spec.Enum.enum_destr_cons_nil' | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: Type ->
key: Prims.eqtype ->
repr: Prims.eqtype ->
e: LowParse.Spec.Enum.enum key repr ->
u1: Prims.unit{Cons? e} ->
u2: Prims.unit{Nil? (LowParse.Spec.Enum.enum_tail e)}
-> LowParse.Spec.Enum.enum_destr_t t e | {
"end_col": 25,
"end_line": 689,
"start_col": 2,
"start_line": 689
} |
Prims.Tot | val enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g | val enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e) = | false | null | false | enum_destr_cons t e g | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.unit",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.enum_destr_t",
"LowParse.Spec.Enum.enum_tail",
"LowParse.Spec.Enum.enum_destr_cons"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e)) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e) | [] | LowParse.Spec.Enum.enum_destr_cons' | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: Type ->
key: Prims.eqtype ->
repr: Prims.eqtype ->
e: LowParse.Spec.Enum.enum key repr ->
u311: u313: Prims.unit{Cons? e} ->
g: LowParse.Spec.Enum.enum_destr_t t (LowParse.Spec.Enum.enum_tail e)
-> LowParse.Spec.Enum.enum_destr_t t e | {
"end_col": 23,
"end_line": 661,
"start_col": 2,
"start_line": 661
} |
Prims.Tot | val fif (u v: Type) (eq: (v -> v -> GTot Type0)) (ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x) | val fif (u v: Type) (eq: (v -> v -> GTot Type0)) (ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
let fif (u v: Type) (eq: (v -> v -> GTot Type0)) (ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq)) = | false | null | false | fun
(cond: bool)
(s_true: (cond_true cond -> u -> Tot v))
(s_false: (cond_false cond -> u -> Tot v))
(x: u)
->
ifc cond (fun h -> s_true () x) (fun h -> s_false () x) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"LowParse.Spec.Enum.if_combinator",
"Prims.bool",
"LowParse.Spec.Combinators.cond_true",
"LowParse.Spec.Combinators.cond_false",
"LowParse.Spec.Enum.feq"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fif (u v: Type) (eq: (v -> v -> GTot Type0)) (ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq)) | [] | LowParse.Spec.Enum.fif | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
u286: Type ->
v: Type ->
eq: (_: v -> _: v -> Prims.GTot Type0) ->
ifc: LowParse.Spec.Enum.if_combinator v eq
-> LowParse.Spec.Enum.if_combinator (_: u286 -> v) (LowParse.Spec.Enum.feq u286 v eq) | {
"end_col": 29,
"end_line": 582,
"start_col": 2,
"start_line": 578
} |
FStar.Pervasives.Lemma | val feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u -> Lemma ((f1 x) `eq` (f2 x))))
: Lemma (feq _ _ eq f1 f2) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi | val feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u -> Lemma ((f1 x) `eq` (f2 x))))
: Lemma (feq _ _ eq f1 f2)
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u -> Lemma ((f1 x) `eq` (f2 x))))
: Lemma (feq _ _ eq f1 f2) = | false | null | true | Classical.forall_intro phi | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Classical.forall_intro",
"LowParse.Spec.Enum.feq"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x)) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u -> Lemma ((f1 x) `eq` (f2 x))))
: Lemma (feq _ _ eq f1 f2) | [] | LowParse.Spec.Enum.feq_intro | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
u279: Type ->
v: Type ->
eq: (_: v -> _: v -> Prims.GTot Type0) ->
f1: (_: u279 -> v) ->
f2: (_: u279 -> v) ->
phi: (x: u279 -> FStar.Pervasives.Lemma (ensures eq (f1 x) (f2 x)))
-> FStar.Pervasives.Lemma (ensures LowParse.Spec.Enum.feq u279 v eq f1 f2) | {
"end_col": 28,
"end_line": 549,
"start_col": 2,
"start_line": 549
} |
Prims.Pure | val enum_destr_cons_nil (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Pure (enum_destr_t t e) (requires (Cons? e /\ Nil? (enum_tail' e))) (ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e | val enum_destr_cons_nil (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Pure (enum_destr_t t e) (requires (Cons? e /\ Nil? (enum_tail' e))) (ensures (fun _ -> True))
let enum_destr_cons_nil (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Pure (enum_destr_t t e) (requires (Cons? e /\ Nil? (enum_tail' e))) (ensures (fun _ -> True)) = | false | null | false | fun
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
->
[@@ inline_let ]let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e': list (key * repr) {e' == e}) ->
match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((f k) <: (y: t{eq y (f x)})))) e | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.enum_key",
"Prims.unit",
"LowParse.Spec.Enum.r_reflexive_t_elim",
"LowParse.Spec.Enum.enum_destr_t",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Cons",
"Prims.uu___is_Nil",
"LowParse.Spec.Enum.enum_tail'",
"Prims.l_True"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e))) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_destr_cons_nil (t: Type) (#key #repr: eqtype) (e: enum key repr)
: Pure (enum_destr_t t e) (requires (Cons? e /\ Nil? (enum_tail' e))) (ensures (fun _ -> True)) | [] | LowParse.Spec.Enum.enum_destr_cons_nil | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | t: Type -> e: LowParse.Spec.Enum.enum key repr -> Prims.Pure (LowParse.Spec.Enum.enum_destr_t t e) | {
"end_col": 5,
"end_line": 679,
"start_col": 2,
"start_line": 671
} |
FStar.Pervasives.Lemma | val list_rev_cons (#t: Type) (a: t) (q: list t) : Lemma (L.rev (a :: q) == (L.rev q) `L.append` [a]) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q | val list_rev_cons (#t: Type) (a: t) (q: list t) : Lemma (L.rev (a :: q) == (L.rev q) `L.append` [a])
let list_rev_cons (#t: Type) (a: t) (q: list t) : Lemma (L.rev (a :: q) == (L.rev q) `L.append` [a]) = | false | null | true | L.rev_rev' (a :: q);
L.rev_rev' q | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"Prims.list",
"FStar.List.Tot.Properties.rev_rev'",
"Prims.unit",
"Prims.Cons",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.List.Tot.Base.rev",
"FStar.List.Tot.Base.append",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val list_rev_cons (#t: Type) (a: t) (q: list t) : Lemma (L.rev (a :: q) == (L.rev q) `L.append` [a]) | [] | LowParse.Spec.Enum.list_rev_cons | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | a: t -> q: Prims.list t
-> FStar.Pervasives.Lemma
(ensures FStar.List.Tot.Base.rev (a :: q) == FStar.List.Tot.Base.rev q @ [a]) | {
"end_col": 14,
"end_line": 801,
"start_col": 2,
"start_line": 800
} |
Prims.Tot | val dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } )) | val dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v) = | false | null | false | match e with
| (k, _) :: _ ->
fun
(v_eq: (k: enum_key e -> v k -> v k -> GTot Type0))
(v_if: (k: enum_key e -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: (k: enum_key e -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: (k: enum_key e -> Tot (r_transitive_t _ (v_eq k))))
(f: (k: enum_key e -> Tot (v k)))
(k': enum_key e)
->
[@@ inline_let ]let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@@ inline_let ]let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@@ inline_let ]let y:v k' = f k in
(y <: (y: v k' {v_eq k' y (f k')})) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"Prims.uu___is_Nil",
"LowParse.Spec.Enum.enum_tail",
"LowParse.Spec.Enum.enum_key",
"Prims.list",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"Prims.unit",
"LowParse.Spec.Enum.r_transitive_t_elim",
"LowParse.Spec.Enum.r_reflexive_t_elim",
"LowParse.Spec.Enum.dep_enum_destr"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type)) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v) | [] | LowParse.Spec.Enum.dep_enum_destr_cons_nil | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
e: LowParse.Spec.Enum.enum key repr ->
u335: Prims.squash (Cons? e /\ Nil? (LowParse.Spec.Enum.enum_tail e)) ->
v: (_: LowParse.Spec.Enum.enum_key e -> Type)
-> LowParse.Spec.Enum.dep_enum_destr e v | {
"end_col": 42,
"end_line": 786,
"start_col": 2,
"start_line": 771
} |
FStar.Pervasives.Lemma | val parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input ==
(parse ((parse_maybe_enum_key p e) `parse_synth` (total_of_maybe_enum_key e)) input)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input | val parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input ==
(parse ((parse_maybe_enum_key p e) `parse_synth` (total_of_maybe_enum_key e)) input))
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input ==
(parse ((parse_maybe_enum_key p e) `parse_synth` (total_of_maybe_enum_key e)) input)) = | false | null | true | parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"Prims.eqtype",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Enum.total_enum",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.parse_synth_eq",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"Prims.unit",
"LowParse.Spec.Enum.maybe_total_enum_key",
"LowParse.Spec.Enum.parse_maybe_enum_key",
"LowParse.Spec.Enum.total_of_maybe_enum_key",
"LowParse.Spec.Enum.maybe_total_enum_key_of_repr",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Enum.parse_maybe_total_enum_key",
"LowParse.Spec.Combinators.parse_synth",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input ==
(parse ((parse_maybe_enum_key p e) `parse_synth` (total_of_maybe_enum_key e)) input)) | [] | LowParse.Spec.Enum.parse_maybe_total_enum_key_eq | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k repr ->
e: LowParse.Spec.Enum.total_enum key repr ->
input: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.parse (LowParse.Spec.Enum.parse_maybe_total_enum_key p e) input ==
LowParse.Spec.Base.parse (LowParse.Spec.Combinators.parse_synth (LowParse.Spec.Enum.parse_maybe_enum_key
p
e)
(LowParse.Spec.Enum.total_of_maybe_enum_key e))
input) | {
"end_col": 51,
"end_line": 453,
"start_col": 2,
"start_line": 451
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q | let list_tl (#t: Type) (l: list t {Cons? l}) = | false | null | false | match l with | _ :: q -> q | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.list",
"Prims.b2t",
"Prims.uu___is_Cons"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val list_tl : l: Prims.list t {Cons? l} -> Prims.list t | [] | LowParse.Spec.Enum.list_tl | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l: Prims.list t {Cons? l} -> Prims.list t | {
"end_col": 15,
"end_line": 905,
"start_col": 2,
"start_line": 904
} |
|
FStar.Pervasives.Lemma | val assoc_append_flip_l_intro (#key #repr: eqtype) (l1 l2: list (key * repr)) (y: repr) (x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x | val assoc_append_flip_l_intro (#key #repr: eqtype) (l1 l2: list (key * repr)) (y: repr) (x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
let rec assoc_append_flip_l_intro (#key #repr: eqtype) (l1 l2: list (key * repr)) (y: repr) (x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x)) = | false | null | true | match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"Prims.eqtype",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.assoc_append_flip_l_intro",
"Prims.unit",
"FStar.List.Tot.Properties.noRepeats_append_elim",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.snd",
"FStar.List.Tot.Properties.map_append",
"LowParse.Spec.Enum.map_fst_flip",
"FStar.List.Tot.Properties.assoc_mem",
"LowParse.Spec.Enum.flip",
"Prims.l_and",
"Prims.b2t",
"FStar.List.Tot.Base.noRepeats",
"FStar.List.Tot.Base.append",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.List.Tot.Base.assoc",
"FStar.Pervasives.Native.Some",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x)) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val assoc_append_flip_l_intro (#key #repr: eqtype) (l1 l2: list (key * repr)) (y: repr) (x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x)) | [
"recursion"
] | LowParse.Spec.Enum.assoc_append_flip_l_intro | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l1: Prims.list (key * repr) -> l2: Prims.list (key * repr) -> y: repr -> x: key
-> FStar.Pervasives.Lemma
(requires
FStar.List.Tot.Base.noRepeats (FStar.List.Tot.Base.map FStar.Pervasives.Native.snd (l1 @ l2)
) /\
FStar.List.Tot.Base.assoc y (FStar.List.Tot.Base.map LowParse.Spec.Enum.flip l2) ==
FStar.Pervasives.Native.Some x)
(ensures
FStar.List.Tot.Base.assoc y (FStar.List.Tot.Base.map LowParse.Spec.Enum.flip (l1 @ l2)) ==
FStar.Pervasives.Native.Some x) | {
"end_col": 38,
"end_line": 823,
"start_col": 2,
"start_line": 816
} |
Prims.Tot | val mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u: squash (e == (L.rev l1) `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u) (decreases l2) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u) | val mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u: squash (e == (L.rev l1) `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u) (decreases l2)
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u: squash (e == (L.rev l1) `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u) (decreases l2) = | false | null | false | match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@@ inline_let ]let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total",
""
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.squash",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.List.Tot.Base.rev",
"LowParse.Spec.Enum.maybe_enum_destr_nil",
"LowParse.Spec.Enum.maybe_enum_destr_cons",
"LowParse.Spec.Enum.mk_maybe_enum_destr'",
"Prims.Cons",
"LowParse.Spec.Enum.list_hd",
"LowParse.Spec.Enum.list_tl",
"Prims.unit",
"LowParse.Spec.Enum.list_append_rev_cons",
"LowParse.Spec.Enum.maybe_enum_destr_t'"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u: squash (e == (L.rev l1) `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u) (decreases l2) | [
"recursion"
] | LowParse.Spec.Enum.mk_maybe_enum_destr' | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: Type ->
e: LowParse.Spec.Enum.enum key repr ->
l1: Prims.list (key * repr) ->
l2: Prims.list (key * repr) ->
u420: Prims.squash (e == FStar.List.Tot.Base.rev l1 @ l2)
-> Prims.Tot (LowParse.Spec.Enum.maybe_enum_destr_t' t e l1 l2 u420) | {
"end_col": 98,
"end_line": 995,
"start_col": 2,
"start_line": 990
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ()) | let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= | false | null | false | dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ()) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t_intro",
"LowParse.Spec.Enum.mk_dep_maybe_enum_destr'",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_dep_maybe_enum_destr : e: LowParse.Spec.Enum.enum key repr -> v: (_: LowParse.Spec.Enum.maybe_enum_key e -> Type)
-> LowParse.Spec.Enum.dep_maybe_enum_destr_t e v | [] | LowParse.Spec.Enum.mk_dep_maybe_enum_destr | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.enum key repr -> v: (_: LowParse.Spec.Enum.maybe_enum_key e -> Type)
-> LowParse.Spec.Enum.dep_maybe_enum_destr_t e v | {
"end_col": 73,
"end_line": 1145,
"start_col": 2,
"start_line": 1145
} |
|
Prims.Tot | val mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) (decreases l2) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))) | val mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) (decreases l2)
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) (decreases l2) = | false | null | false | match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ ->
dep_maybe_enum_destr_cons e
v
l1
l2
u1
(mk_dep_maybe_enum_destr' e
v
(list_hd l2 :: l1)
(list_tl l2)
(list_append_rev_cons l1 (list_hd l2) (list_tl l2))) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total",
""
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.squash",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.List.Tot.Base.rev",
"LowParse.Spec.Enum.dep_maybe_enum_destr_nil",
"LowParse.Spec.Enum.dep_maybe_enum_destr_cons",
"LowParse.Spec.Enum.mk_dep_maybe_enum_destr'",
"Prims.Cons",
"LowParse.Spec.Enum.list_hd",
"LowParse.Spec.Enum.list_tl",
"LowParse.Spec.Enum.list_append_rev_cons",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t'"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) (decreases l2) | [
"recursion"
] | LowParse.Spec.Enum.mk_dep_maybe_enum_destr' | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
e: LowParse.Spec.Enum.enum key repr ->
v: (_: LowParse.Spec.Enum.maybe_enum_key e -> Type) ->
l1: Prims.list (key * repr) ->
l2: Prims.list (key * repr) ->
u1: Prims.squash (e == FStar.List.Tot.Base.rev l1 @ l2)
-> Prims.Tot (LowParse.Spec.Enum.dep_maybe_enum_destr_t' e v l1 l2 u1) | {
"end_col": 162,
"end_line": 1138,
"start_col": 2,
"start_line": 1136
} |
Prims.GTot | val list_forallp (#t: Type) (p: (t -> GTot Type0)) (l: list t) : GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q | val list_forallp (#t: Type) (p: (t -> GTot Type0)) (l: list t) : GTot Type0
let rec list_forallp (#t: Type) (p: (t -> GTot Type0)) (l: list t) : GTot Type0 = | false | null | false | match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"sometrivial"
] | [
"Prims.list",
"Prims.l_True",
"Prims.l_and",
"LowParse.Spec.Enum.list_forallp"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val list_forallp (#t: Type) (p: (t -> GTot Type0)) (l: list t) : GTot Type0 | [
"recursion"
] | LowParse.Spec.Enum.list_forallp | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: (_: t -> Prims.GTot Type0) -> l: Prims.list t -> Prims.GTot Type0 | {
"end_col": 37,
"end_line": 1152,
"start_col": 2,
"start_line": 1150
} |
Prims.Tot | val dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } )) | val dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) = | false | null | false | fun
(v_eq: (k: maybe_enum_key e -> v k -> v k -> GTot Type0))
(v_if: (k: maybe_enum_key e -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: (k: maybe_enum_key e -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: (k: maybe_enum_key e -> Tot (r_transitive_t _ (v_eq k))))
(f: (k: maybe_enum_key e -> Tot (v k)))
(x: repr{maybe_enum_key_of_repr_not_in e l1 x})
->
((L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
[@@ inline_let ]let y:v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@@ inline_let ]let _ =
v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x))
in
y)
<:
(y:
v (maybe_enum_key_of_repr e x)
{v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))})) | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Nil",
"Prims.eq2",
"FStar.List.Tot.Base.append",
"FStar.List.Tot.Base.rev",
"Prims.Nil",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Spec.Enum.r_reflexive_t",
"LowParse.Spec.Enum.r_transitive_t",
"LowParse.Spec.Enum.maybe_enum_key_of_repr_not_in",
"Prims.unit",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"LowParse.Spec.Enum.Unknown",
"Prims._assert",
"FStar.List.Tot.Properties.rev_mem",
"FStar.List.Tot.Base.map",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.list_rev_map",
"FStar.List.Tot.Properties.append_l_nil",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t'"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) [])) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1) | [] | LowParse.Spec.Enum.dep_maybe_enum_destr_nil | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
e: LowParse.Spec.Enum.enum key repr ->
v: (_: LowParse.Spec.Enum.maybe_enum_key e -> Type) ->
l1: Prims.list (key * repr) ->
l2: Prims.list (key * repr) ->
u1: Prims.squash (Nil? l2 /\ e == FStar.List.Tot.Base.rev l1 @ [])
-> LowParse.Spec.Enum.dep_maybe_enum_destr_t' e v l1 l2 u1 | {
"end_col": 117,
"end_line": 1124,
"start_col": 2,
"start_line": 1106
} |
FStar.Pervasives.Lemma | val list_forallp_mem (#t: eqtype) (p: (t -> GTot Type0)) (l: list t)
: Lemma (list_forallp p l <==> (forall x. L.mem x l ==> p x)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q | val list_forallp_mem (#t: eqtype) (p: (t -> GTot Type0)) (l: list t)
: Lemma (list_forallp p l <==> (forall x. L.mem x l ==> p x))
let rec list_forallp_mem (#t: eqtype) (p: (t -> GTot Type0)) (l: list t)
: Lemma (list_forallp p l <==> (forall x. L.mem x l ==> p x)) = | false | null | true | match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"lemma"
] | [
"Prims.eqtype",
"Prims.list",
"LowParse.Spec.Enum.list_forallp_mem",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_iff",
"LowParse.Spec.Enum.list_forallp",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.b2t",
"FStar.List.Tot.Base.mem",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val list_forallp_mem (#t: eqtype) (p: (t -> GTot Type0)) (l: list t)
: Lemma (list_forallp p l <==> (forall x. L.mem x l ==> p x)) | [
"recursion"
] | LowParse.Spec.Enum.list_forallp_mem | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: (_: t -> Prims.GTot Type0) -> l: Prims.list t
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Enum.list_forallp p l <==> (forall (x: t). FStar.List.Tot.Base.mem x l ==> p x)) | {
"end_col": 34,
"end_line": 1158,
"start_col": 2,
"start_line": 1156
} |
Prims.Tot | val enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (enum_repr_of_key'_t e) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons_nil e | val enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (enum_repr_of_key'_t e)
let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (enum_repr_of_key'_t e) = | false | null | false | enum_repr_of_key_cons_nil e | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.unit",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"Prims.uu___is_Nil",
"LowParse.Spec.Enum.enum_tail'",
"LowParse.Spec.Enum.enum_repr_of_key_cons_nil",
"LowParse.Spec.Enum.enum_repr_of_key'_t"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e
inline_for_extraction
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons e f
inline_for_extraction
let enum_repr_of_key_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun (x: enum_key e) ->
(r <: (r: enum_repr e { enum_repr_of_key e x == r } ))))
e
inline_for_extraction
let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } ) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit{Cons? e})
(u2: unit{Nil? (enum_tail' e)})
: Tot (enum_repr_of_key'_t e) | [] | LowParse.Spec.Enum.enum_repr_of_key_cons_nil' | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
key: Prims.eqtype ->
repr: Prims.eqtype ->
e: LowParse.Spec.Enum.enum key repr ->
u1: Prims.unit{Cons? e} ->
u2: Prims.unit{Nil? (LowParse.Spec.Enum.enum_tail' e)}
-> LowParse.Spec.Enum.enum_repr_of_key'_t e | {
"end_col": 29,
"end_line": 1261,
"start_col": 2,
"start_line": 1261
} |
Prims.Tot | val maybe_enum_key_of_repr'_t_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Tot (maybe_enum_key_of_repr'_t e) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let maybe_enum_key_of_repr'_t_cons'
(key repr: eqtype)
(e: enum key repr )
(u: unit { Cons? e } )
(g : maybe_enum_key_of_repr'_t (enum_tail' e))
: Tot (maybe_enum_key_of_repr'_t e)
= maybe_enum_key_of_repr'_t_cons e g | val maybe_enum_key_of_repr'_t_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Tot (maybe_enum_key_of_repr'_t e)
let maybe_enum_key_of_repr'_t_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Tot (maybe_enum_key_of_repr'_t e) = | false | null | false | maybe_enum_key_of_repr'_t_cons e g | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.unit",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.maybe_enum_key_of_repr'_t",
"LowParse.Spec.Enum.enum_tail'",
"LowParse.Spec.Enum.maybe_enum_key_of_repr'_t_cons"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e
inline_for_extraction
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons e f
inline_for_extraction
let enum_repr_of_key_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun (x: enum_key e) ->
(r <: (r: enum_repr e { enum_repr_of_key e x == r } ))))
e
inline_for_extraction
let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons_nil e
let enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma
(requires (e == l1 `L.append` (kr :: l2)))
(ensures (list_mem (fst kr) (list_map fst e) /\ enum_repr_of_key e (fst kr) == snd kr /\ list_mem (snd kr) (list_map snd e) /\ enum_key_of_repr e (snd kr) == fst kr))
= L.map_append fst l1 (kr :: l2);
L.noRepeats_append_elim (L.map fst l1) (L.map fst (kr :: l2));
L.assoc_mem (fst kr) l1;
L.assoc_mem (fst kr) e;
L.assoc_append_elim_l (fst kr) l1 (kr :: l2);
enum_key_of_repr_of_key e (fst kr)
let maybe_enum_key_of_repr'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: repr) ->
Tot (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } )
#push-options "--z3rlimit 32"
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun x -> ((
if r = x
then Known k
else Unknown x
) <: (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } ))))
e
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (maybe_enum_key_of_repr'_t e)
= maybe_enum_key_of_repr'_t_cons_nil e
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons
(#key #repr: eqtype)
(e: enum key repr )
(g : maybe_enum_key_of_repr'_t (enum_tail' e))
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun x -> ((
if r = x
then Known k
else
let y : maybe_enum_key (enum_tail' e) = g x in
match y with
| Known k' -> Known (k' <: key)
| Unknown x' -> Unknown x
) <: (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } ))))
e
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons'
(key repr: eqtype)
(e: enum key repr )
(u: unit { Cons? e } )
(g : maybe_enum_key_of_repr'_t (enum_tail' e)) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val maybe_enum_key_of_repr'_t_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit{Cons? e})
(g: maybe_enum_key_of_repr'_t (enum_tail' e))
: Tot (maybe_enum_key_of_repr'_t e) | [] | LowParse.Spec.Enum.maybe_enum_key_of_repr'_t_cons' | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
key: Prims.eqtype ->
repr: Prims.eqtype ->
e: LowParse.Spec.Enum.enum key repr ->
u528: u530: Prims.unit{Cons? e} ->
g: LowParse.Spec.Enum.maybe_enum_key_of_repr'_t (LowParse.Spec.Enum.enum_tail' e)
-> LowParse.Spec.Enum.maybe_enum_key_of_repr'_t e | {
"end_col": 36,
"end_line": 1342,
"start_col": 2,
"start_line": 1342
} |
Prims.Tot | val dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d | val dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v) = | false | null | false | d | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t'",
"Prims.Nil",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ()) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v) | [] | LowParse.Spec.Enum.dep_maybe_enum_destr_t_intro | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
e: LowParse.Spec.Enum.enum key repr ->
v: (_: LowParse.Spec.Enum.maybe_enum_key e -> Type) ->
d: LowParse.Spec.Enum.dep_maybe_enum_destr_t' e v [] e ()
-> LowParse.Spec.Enum.dep_maybe_enum_destr_t e v | {
"end_col": 3,
"end_line": 1044,
"start_col": 2,
"start_line": 1044
} |
Prims.Pure | val enum_repr_of_key_cons_nil (#key #repr: eqtype) (e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let enum_repr_of_key_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun (x: enum_key e) ->
(r <: (r: enum_repr e { enum_repr_of_key e x == r } ))))
e | val enum_repr_of_key_cons_nil (#key #repr: eqtype) (e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
let enum_repr_of_key_cons_nil (#key #repr: eqtype) (e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True)) = | false | null | false | (fun (e': list (key * repr) {e' == e}) ->
match e' with
| [k, r] -> (fun (x: enum_key e) -> (r <: (r: enum_repr e {enum_repr_of_key e x == r})))) e | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.enum_repr",
"Prims.eq2",
"LowParse.Spec.Enum.enum_repr_of_key",
"LowParse.Spec.Enum.enum_repr_of_key'_t",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"Prims.uu___is_Nil",
"LowParse.Spec.Enum.enum_tail'",
"Prims.l_True"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e
inline_for_extraction
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons e f
inline_for_extraction
let enum_repr_of_key_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e))) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val enum_repr_of_key_cons_nil (#key #repr: eqtype) (e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True)) | [] | LowParse.Spec.Enum.enum_repr_of_key_cons_nil | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.enum key repr -> Prims.Pure (LowParse.Spec.Enum.enum_repr_of_key'_t e) | {
"end_col": 6,
"end_line": 1252,
"start_col": 2,
"start_line": 1248
} |
Prims.Pure | val maybe_enum_key_of_repr'_t_cons_nil (#key #repr: eqtype) (e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let maybe_enum_key_of_repr'_t_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun x -> ((
if r = x
then Known k
else Unknown x
) <: (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } ))))
e | val maybe_enum_key_of_repr'_t_cons_nil (#key #repr: eqtype) (e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
let maybe_enum_key_of_repr'_t_cons_nil (#key #repr: eqtype) (e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True)) = | false | null | false | (fun (e': list (key * repr) {e' == e}) ->
match e' with
| [k, r] ->
(fun x ->
((if r = x then Known k else Unknown x)
<:
(k: maybe_enum_key e {k == maybe_enum_key_of_repr e x})))) e | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"Prims.op_Equality",
"LowParse.Spec.Enum.Known",
"Prims.bool",
"LowParse.Spec.Enum.Unknown",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.eq2",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"LowParse.Spec.Enum.maybe_enum_key_of_repr'_t",
"Prims.l_and",
"Prims.b2t",
"Prims.uu___is_Cons",
"FStar.Pervasives.Native.tuple2",
"Prims.uu___is_Nil",
"LowParse.Spec.Enum.enum_tail'",
"Prims.l_True"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' ()
let forall_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> GTot Type0)
(f_known: squash (list_forallp (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e)))
(f_unknown: (
(x: value) ->
Tot (squash (list_mem x (list_map snd e) == false ==> f (Unknown x)))
))
: Tot (squash (forall (x: maybe_enum_key e) . f x))
= let g
(x: maybe_enum_key e)
: Lemma
(f x)
= let u : squash (f x) =
destruct_maybe_enum_key
e
(fun y -> squash (f y))
(fun x' u -> list_forallp_mem (fun (x: key) -> list_mem x (list_map fst e) /\ f (Known x)) (list_map fst e))
(fun x' u -> f_unknown x') x
in
assert (f x)
in
Classical.forall_intro g
(* Converting enum keys to their representation, using combinators *)
let enum_repr_of_key'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: enum_key e) ->
Tot (r: enum_repr e { r == enum_repr_of_key e x } )
inline_for_extraction
let enum_repr_of_key_cons
(#key #repr: eqtype)
(e: enum key repr)
(f : enum_repr_of_key'_t (enum_tail' e))
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, r) :: _ ->
(fun (x: enum_key e) -> (
if k = x
then (r <: repr)
else (f (x <: key) <: repr)
) <: (r: enum_repr e { enum_repr_of_key e x == r } )))
e
inline_for_extraction
let enum_repr_of_key_cons'
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(f : enum_repr_of_key'_t (enum_tail' e))
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons e f
inline_for_extraction
let enum_repr_of_key_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_repr_of_key'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= (fun (e' : list (key * repr) { e' == e } ) -> match e' with
| [(k, r)] ->
(fun (x: enum_key e) ->
(r <: (r: enum_repr e { enum_repr_of_key e x == r } ))))
e
inline_for_extraction
let enum_repr_of_key_cons_nil'
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail' e) } )
: Tot (enum_repr_of_key'_t e)
= enum_repr_of_key_cons_nil e
let enum_repr_of_key_append_cons
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key & repr))
(kr: (key & repr))
(l2: list (key & repr))
: Lemma
(requires (e == l1 `L.append` (kr :: l2)))
(ensures (list_mem (fst kr) (list_map fst e) /\ enum_repr_of_key e (fst kr) == snd kr /\ list_mem (snd kr) (list_map snd e) /\ enum_key_of_repr e (snd kr) == fst kr))
= L.map_append fst l1 (kr :: l2);
L.noRepeats_append_elim (L.map fst l1) (L.map fst (kr :: l2));
L.assoc_mem (fst kr) l1;
L.assoc_mem (fst kr) e;
L.assoc_append_elim_l (fst kr) l1 (kr :: l2);
enum_key_of_repr_of_key e (fst kr)
let maybe_enum_key_of_repr'_t
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (x: repr) ->
Tot (k: maybe_enum_key e { k == maybe_enum_key_of_repr e x } )
#push-options "--z3rlimit 32"
inline_for_extraction
let maybe_enum_key_of_repr'_t_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e))) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val maybe_enum_key_of_repr'_t_cons_nil (#key #repr: eqtype) (e: enum key repr)
: Pure (maybe_enum_key_of_repr'_t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True)) | [] | LowParse.Spec.Enum.maybe_enum_key_of_repr'_t_cons_nil | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | e: LowParse.Spec.Enum.enum key repr -> Prims.Pure (LowParse.Spec.Enum.maybe_enum_key_of_repr'_t e) | {
"end_col": 5,
"end_line": 1303,
"start_col": 2,
"start_line": 1296
} |
Prims.Tot | val destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: (maybe_enum_key e -> Tot Type))
(f_known: (x: key -> u: squash (list_mem x (list_map fst e)) -> Tot (f (Known x))))
(f_unknown:
(x: value -> u: squash (list_mem x (list_map snd e) == false) -> Tot (f (Unknown x))))
(x: maybe_enum_key e)
: Tot (f x) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e)
: Tot (f x)
= match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' () | val destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: (maybe_enum_key e -> Tot Type))
(f_known: (x: key -> u: squash (list_mem x (list_map fst e)) -> Tot (f (Known x))))
(f_unknown:
(x: value -> u: squash (list_mem x (list_map snd e) == false) -> Tot (f (Unknown x))))
(x: maybe_enum_key e)
: Tot (f x)
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: (maybe_enum_key e -> Tot Type))
(f_known: (x: key -> u: squash (list_mem x (list_map fst e)) -> Tot (f (Known x))))
(f_unknown:
(x: value -> u: squash (list_mem x (list_map snd e) == false) -> Tot (f (Unknown x))))
(x: maybe_enum_key e)
: Tot (f x) = | false | null | false | match x with
| Known x' -> f_known x' ()
| Unknown x' -> f_unknown x' () | {
"checked_file": "LowParse.Spec.Enum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.Enum.fst"
} | [
"total"
] | [
"Prims.eqtype",
"LowParse.Spec.Enum.enum",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.squash",
"Prims.b2t",
"LowParse.Spec.Enum.list_mem",
"LowParse.Spec.Enum.list_map",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.fst",
"LowParse.Spec.Enum.Known",
"Prims.eq2",
"Prims.bool",
"FStar.Pervasives.Native.snd",
"LowParse.Spec.Enum.Unknown",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.unknown_enum_repr"
] | [] | module LowParse.Spec.Enum
include LowParse.Spec.Combinators
module L = FStar.List.Tot
[@Norm]
let rec list_map
(#a #b: Type)
(f: (a -> Tot b))
(l: list a)
: Tot (l' : list b { l' == L.map f l } )
= match l with
| [] -> []
| a :: q -> f a :: list_map f q
type enum (key: eqtype) (repr: eqtype) = (l: list (key * repr) {
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l)
})
[@Norm]
let rec list_mem
(#t: eqtype)
(x: t)
(l: list t)
: Tot (y: bool { y == true <==> L.mem x l == true } )
= match l with
| [] -> false
| a :: q -> (x = a || list_mem x q)
inline_for_extraction
let enum_key (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (s: key { list_mem s (list_map fst e) } )
inline_for_extraction
let make_enum_key (#key #repr: eqtype) (e: enum key repr) (k: key) : Pure (enum_key e)
(requires (list_mem k (list_map fst e)))
(ensures (fun k' -> k == (k' <: key)))
= k
inline_for_extraction
let enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot eqtype = (r: repr { list_mem r (list_map snd e) } )
let flip (#a #b: Type) (c: (a * b)) : Tot (b * a) = let (ca, cb) = c in (cb, ca)
let rec map_flip_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map flip (list_map flip l) == l)
= match l with
| [] -> ()
| _ :: q -> map_flip_flip q
let rec map_fst_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map fst (list_map flip l) == list_map snd l)
= match l with
| [] -> ()
| _ :: q -> map_fst_flip q
let rec map_snd_flip (#a #b: Type) (l: list (a * b)) : Lemma
(list_map snd (list_map flip l) == list_map fst l)
= match l with
| [] -> ()
| _ :: q -> map_snd_flip q
let rec assoc_mem_snd
(#a #b: eqtype)
(l: list (a * b))
(x: a)
(y: b)
: Lemma
(requires (L.assoc x l == Some y))
(ensures (list_mem y (list_map snd l) == true))
(decreases l)
= let ((x', y') :: l') = l in
if x' = x
then ()
else assoc_mem_snd l' x y
let rec assoc_flip_elim
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc y (list_map flip l) == Some x
))
(ensures (
L.assoc x l == Some y
))
(decreases l)
= let ((x', y') :: l') = l in
if y' = y
then ()
else begin
if x' = x
then begin
assert (list_mem x' (list_map fst l') == false);
assoc_mem_snd (list_map flip l') y x;
map_snd_flip l';
assert False
end
else
assoc_flip_elim l' y x
end
let rec assoc_flip_intro
(#a #b: eqtype)
(l: list (a * b))
(y: b)
(x: a)
: Lemma
(requires (
L.noRepeats (list_map fst l) /\
L.noRepeats (list_map snd l) /\
L.assoc x l == Some y
))
(ensures (
L.assoc y (list_map flip l) == Some x
))
= map_fst_flip l;
map_snd_flip l;
map_flip_flip l;
assoc_flip_elim (list_map flip l) x y
let enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Pure (enum_key e)
(requires True)
(ensures (fun y -> L.assoc y e == Some r))
= map_fst_flip e;
let e' = list_map #(key * repr) #(repr * key) flip e in
L.assoc_mem r e';
let k = Some?.v (L.assoc r e') in
assoc_flip_elim e r k;
L.assoc_mem k e;
(k <: enum_key e)
let parse_enum_key_cond
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: GTot bool
= list_mem r (list_map snd e)
let parse_enum_key_synth
(#key #repr: eqtype)
(e: enum key repr)
(r: repr { parse_enum_key_cond e r == true } )
: GTot (enum_key e)
= enum_key_of_repr e r
let parse_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser (parse_filter_kind k) (enum_key e))
= (p
`parse_filter`
parse_enum_key_cond e
)
`parse_synth`
parse_enum_key_synth e
let enum_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Pure (enum_repr e)
(requires True)
(ensures (fun r -> L.assoc k e == Some r))
= L.assoc_mem k e;
let r = Some?.v (L.assoc k e) in
assoc_flip_intro e r k;
L.assoc_mem r (list_map flip e);
map_fst_flip e;
(r <: enum_repr e)
let enum_repr_of_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: enum_repr e)
: Lemma
(enum_repr_of_key e (enum_key_of_repr e r) == r)
= ()
let enum_key_of_repr_of_key
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: Lemma
(enum_key_of_repr e (enum_repr_of_key e k) == k)
= assoc_flip_intro e (enum_repr_of_key e k) k
let serialize_enum_key_synth_recip
(#key #repr: eqtype)
(e: enum key repr)
(k: enum_key e)
: GTot (r: repr { parse_enum_key_cond e r == true } )
= enum_repr_of_key e k
let serialize_enum_key_synth_inverse
(#key #repr: eqtype)
(e: enum key repr)
: Lemma
(synth_inverse (parse_enum_key_synth e) (serialize_enum_key_synth_recip e))
= Classical.forall_intro (enum_key_of_repr_of_key e)
let serialize_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_enum_key p e))
= serialize_enum_key_synth_inverse e;
serialize_synth
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
let serialize_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: enum_key e)
: Lemma
(serialize (serialize_enum_key p s e) x == serialize s (enum_repr_of_key e x))
= serialize_enum_key_synth_inverse e;
serialize_synth_eq
(parse_filter p (parse_enum_key_cond e))
(parse_enum_key_synth e)
(serialize_filter s (parse_enum_key_cond e))
(serialize_enum_key_synth_recip e)
()
x
inline_for_extraction
let unknown_enum_repr (#key #repr: eqtype) (e: enum key repr) : Tot Type =
(r: repr { list_mem r (list_map snd e) == false } )
type maybe_enum_key (#key #repr: eqtype) (e: enum key repr) =
| Known of (enum_key e)
| Unknown of (unknown_enum_repr e)
let maybe_enum_key_of_repr
(#key #repr: eqtype)
(e: enum key repr)
(r: repr)
: Tot (maybe_enum_key e)
= if list_mem r (list_map snd e)
then Known (enum_key_of_repr e r)
else Unknown r
let parse_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
: Tot (parser k (maybe_enum_key e))
= p `parse_synth` (maybe_enum_key_of_repr e)
let parse_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_enum_key p e) input == (match parse p input with
| Some (x, consumed) -> Some (maybe_enum_key_of_repr e x, consumed)
| _ -> None
))
= parse_synth_eq p (maybe_enum_key_of_repr e) input
let parse_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: enum key repr)
(input: bytes)
: Lemma
(parse (parse_enum_key p e) input == (match parse p input with
| Some (x, consumed) ->
begin match maybe_enum_key_of_repr e x with
| Known k -> Some (k, consumed)
| _ -> None
end
| _ -> None
))
= parse_filter_eq p (parse_enum_key_cond e) input;
parse_synth_eq (p `parse_filter` parse_enum_key_cond e) (parse_enum_key_synth e) input
let repr_of_maybe_enum_key
(#key #repr: eqtype)
(e: enum key repr)
(x: maybe_enum_key e)
: Tot (r: repr { maybe_enum_key_of_repr e r == x } )
= match x with
| Known k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| Unknown r -> r
let serialize_maybe_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: enum key repr)
: Tot (serializer (parse_maybe_enum_key p e))
= serialize_synth p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) ()
let serialize_maybe_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(#p: parser k repr)
(s: serializer p)
(e: enum key repr)
(x: maybe_enum_key e)
: Lemma
(serialize (serialize_maybe_enum_key p s e) x == serialize s (repr_of_maybe_enum_key e x))
= serialize_synth_eq p (maybe_enum_key_of_repr e) s (repr_of_maybe_enum_key e) () x
let is_total_enum (#key: eqtype) (#repr: eqtype) (l: list (key * repr)) : GTot Type0 =
forall (k: key) . {:pattern (list_mem k (list_map fst l))} list_mem k (list_map fst l)
let total_enum (key: eqtype) (repr: eqtype) : Tot eqtype =
(l: enum key repr { is_total_enum l } )
let synth_total_enum_key
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: enum_key l)
: Tot key
= let k' : key = k in
k'
let parse_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(l: total_enum key repr)
: Tot (parser (parse_filter_kind k) key)
= parse_enum_key p l `parse_synth` (synth_total_enum_key l)
let synth_total_enum_key_recip
(#key: eqtype)
(#repr: eqtype)
(l: total_enum key repr)
(k: key)
: Tot (k' : enum_key l { synth_total_enum_key l k' == k } )
= k
let serialize_total_enum_key
(#k: parser_kind)
(#key: eqtype)
(#repr: eqtype)
(p: parser k repr)
(s: serializer p)
(l: total_enum key repr)
: Tot (serializer (parse_total_enum_key p l))
= serialize_synth (parse_enum_key p l) (synth_total_enum_key l) (serialize_enum_key p s l) (synth_total_enum_key_recip l) ()
type maybe_total_enum_key (#key #repr: eqtype) (e: total_enum key repr) =
| TotalKnown of key
| TotalUnknown of (unknown_enum_repr e)
let maybe_total_enum_key_of_repr
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Tot (maybe_total_enum_key e)
= if list_mem r (list_map snd e)
then TotalKnown (enum_key_of_repr e r)
else TotalUnknown r
let parse_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
: Tot (parser k (maybe_total_enum_key e))
= p `parse_synth` (maybe_total_enum_key_of_repr e)
let repr_of_maybe_total_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (r: repr { maybe_total_enum_key_of_repr e r == k } )
= match k with
| TotalKnown k' ->
enum_key_of_repr_of_key e k' ;
enum_repr_of_key e k'
| TotalUnknown r -> r
let serialize_maybe_total_enum_key
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(s: serializer p)
(e: total_enum key repr)
: Tot (serializer (parse_maybe_total_enum_key p e))
= serialize_synth p (maybe_total_enum_key_of_repr e) s (repr_of_maybe_total_enum_key e) ()
inline_for_extraction
let maybe_enum_key_of_total
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_total_enum_key e)
: Tot (maybe_enum_key e)
= match k with
| TotalKnown ek -> Known (ek <: key)
| TotalUnknown r -> Unknown r
inline_for_extraction
let total_of_maybe_enum_key
(#key #repr: eqtype)
(e: total_enum key repr)
(k: maybe_enum_key e)
: Tot (maybe_total_enum_key e)
= match k with
| Known ek -> TotalKnown (ek <: key)
| Unknown r -> TotalUnknown r
let maybe_total_enum_key_of_repr_eq
(#key #repr: eqtype)
(e: total_enum key repr)
(r: repr)
: Lemma
(maybe_total_enum_key_of_repr e r == total_of_maybe_enum_key e (maybe_enum_key_of_repr e r))
= ()
let parse_maybe_total_enum_key_eq
(#k: parser_kind)
(#key #repr: eqtype)
(p: parser k repr)
(e: total_enum key repr)
(input: bytes)
: Lemma
(parse (parse_maybe_total_enum_key p e) input == (parse (parse_maybe_enum_key p e `parse_synth` total_of_maybe_enum_key e) input))
= parse_synth_eq p (maybe_total_enum_key_of_repr e) input;
parse_synth_eq (parse_maybe_enum_key p e) (total_of_maybe_enum_key e) input;
parse_synth_eq p (maybe_enum_key_of_repr e) input
(* Destructors *)
(* Universal destructor *)
let r_reflexive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x: t) . {:pattern (r x x)} r x x
inline_for_extraction
let r_reflexive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> Lemma (r x x)
let r_reflexive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_reflexive_t t r)
: Lemma
(r_reflexive_prop t r)
= Classical.forall_intro phi
let r_transitive_prop
(t: Type)
(r: (t -> t -> GTot Type0))
: GTot Type0
= forall (x y z: t) . {:pattern (r x y); (r y z)} (r x y /\ r y z) ==> r x z
inline_for_extraction
let r_transitive_t
(t: Type)
(r: (t -> t -> GTot Type0))
: Tot Type
= (x: t) -> (y: t) -> (z: t) -> Lemma ((r x y /\ r y z) ==> r x z)
let r_transitive_t_elim
(t: Type)
(r: (t -> t -> GTot Type0))
(phi: r_transitive_t t r)
: Lemma
(r_transitive_prop t r)
= Classical.forall_intro_3 phi
inline_for_extraction
let if_combinator
(t: Type)
(eq: (t -> t -> GTot Type0))
: Tot Type
= (cond: bool) ->
(sv_true: (cond_true cond -> Tot t)) ->
(sv_false: (cond_false cond -> Tot t)) ->
Tot (y: t { eq y (if cond then sv_true () else sv_false ()) } )
inline_for_extraction
let default_if
(t: Type)
: Tot (if_combinator t (eq2 #t))
= fun
(cond: bool)
(s_true: (cond_true cond -> Tot t))
(s_false: (cond_false cond -> Tot t))
-> (if cond
then s_true ()
else s_false ()) <: (y: t { y == (if cond then s_true () else s_false ()) } )
let feq
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
: GTot Type0
= (forall (x: u) . {:pattern (f1 x); (f2 x)} eq (f1 x) (f2 x))
(* #!$% patterns on forall, the following proofs should be trivial and now they aren't *)
let feq_elim
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(x: u)
: Lemma
(requires (feq u v eq f1 f2))
(ensures (f1 x `eq` f2 x))
= ()
let feq_intro
(u v: Type)
(eq: (v -> v -> GTot Type0))
(f1 f2: (u -> Tot v))
(phi: (x: u) -> Lemma (f1 x `eq` f2 x))
: Lemma (feq _ _ eq f1 f2)
= Classical.forall_intro phi
let feq_trans
(u v: Type)
(eq: (v -> v -> GTot Type0))
: Pure (r_transitive_t _ (feq _ _ eq))
(requires (r_transitive_prop _ eq))
(ensures (fun _ -> True))
= let phi
(f1 f2 f3: (u -> Tot v))
: Lemma
(requires (feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3))
(ensures (feq _ _ eq f1 f3))
= feq_intro _ _ eq f1 f3 (fun x -> assert (f1 x `eq` f2 x /\ f2 x `eq` f3 x))
in
let phi2
(f1 f2 f3: (u -> Tot v))
: Lemma
((feq _ _ eq f1 f2 /\ feq _ _ eq f2 f3) ==> feq _ _ eq f1 f3)
= Classical.move_requires (phi f1 f2) f3
in
phi2
inline_for_extraction
let fif
(u v: Type)
(eq: (v -> v -> GTot Type0))
(ifc: if_combinator v eq)
: Tot (if_combinator (u -> Tot v) (feq u v eq))
= fun (cond: bool) (s_true: (cond_true cond -> u -> Tot v)) (s_false: (cond_false cond -> u -> Tot v)) (x: u) ->
ifc
cond
(fun h -> s_true () x)
(fun h -> s_false () x)
inline_for_extraction
let enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: enum_key e) -> Tot t)) ->
(x: enum_key e) ->
Tot (y: t { eq y (f x) } )
inline_for_extraction
let enum_tail'
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum key repr)
(requires True)
(ensures (fun y -> Cons? e ==> (let (_ :: y') = e in y == y')))
= match e with _ :: y -> y | _ -> []
inline_for_extraction
let enum_tail
(#key #repr: eqtype)
(e: enum key repr)
: Tot (enum key repr)
= enum_tail' e
inline_for_extraction
let enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(g: enum_destr_t t (enum_tail' e))
: Pure (enum_destr_t t e)
(requires (Cons? e))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
[@inline_let]
let f' : (enum_key (enum_tail' e) -> Tot t) =
(fun (x' : enum_key (enum_tail' e)) ->
[@inline_let]
let (x_ : enum_key e) = (x' <: key) in
f x_
)
in
[@inline_let]
let (y: t) =
ift
((k <: key) = x)
(fun h -> f k)
(fun h ->
[@inline_let]
let x' : enum_key (enum_tail' e) = (x <: key) in
(g eq ift eq_refl eq_trans f' x' <: t))
in
y
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u: unit { Cons? e } )
(g: enum_destr_t t (enum_tail e))
: Tot (enum_destr_t t e)
= enum_destr_cons t e g
inline_for_extraction
let enum_destr_cons_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Pure (enum_destr_t t e)
(requires (Cons? e /\ Nil? (enum_tail' e)))
(ensures (fun _ -> True))
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
(fun (e' : list (key * repr) { e' == e } ) -> match e' with
| (k, _) :: _ ->
(fun (f: (enum_key e -> Tot t)) (x: enum_key e) -> ((
f k
) <: (y: t { eq y (f x) } )))
) e
inline_for_extraction
let enum_destr_cons_nil'
(t: Type)
(key repr: eqtype)
(e: enum key repr)
(u1: unit { Cons? e } )
(u2: unit { Nil? (enum_tail e) } )
: Tot (enum_destr_t t e)
= enum_destr_cons_nil t e
(* Dependent destructor *)
inline_for_extraction
let dep_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (enum_key e -> Tot (Type u#a)))
: Tot (Type)
= (v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: enum_key e) -> Tot (v k))) ->
(k: enum_key e) ->
Tot (y: v k { v_eq k y (f k) } )
module L = FStar.List.Tot
inline_for_extraction
let dep_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e))
(v: (enum_key e -> Tot Type))
(destr: dep_enum_destr (enum_tail e) (fun (k' : enum_key (enum_tail e)) -> v (k' <: key)))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' =
v_if k' (k = k') (fun _ ->
[@inline_let]
let y : v k' = f k in
y
) (fun _ ->
[@inline_let]
let v' (k: enum_key (enum_tail e)) : Tot Type = v (k <: key) in
[@inline_let]
let v'_eq (k: enum_key (enum_tail e)) : Tot (v' k -> v' k -> GTot Type0) = v_eq (k <: key) in
[@inline_let]
let v'_if (k: enum_key (enum_tail e)) : Tot (if_combinator (v' k) (v'_eq k)) = v_if (k <: key) in
[@inline_let]
let v'_eq_refl (k: enum_key (enum_tail e)) : Tot (r_reflexive_t _ (v'_eq k)) = v_eq_refl (k <: key) in
[@inline_let]
let v'_eq_trans (k: enum_key (enum_tail e)) : Tot (r_transitive_t _ (v'_eq k)) = v_eq_trans (k <: key) in
[@inline_let]
let f' (k: enum_key (enum_tail e)) : Tot (v' k) = f (k <: key) in
[@inline_let]
let k' : key = k' in
[@inline_let]
let _ = assert (k' <> k) in
[@inline_let]
let _ = assert (L.mem k' (L.map fst (enum_tail e))) in
[@inline_let]
let (y: v' k') =
destr v'_eq v'_if v'_eq_refl v'_eq_trans f' k'
in
y
)
in
(y <: (y: v k' { v_eq k' y (f k') } ))
inline_for_extraction
let dep_enum_destr_cons_nil
(#key #repr: eqtype)
(e: enum key repr)
(u: squash (Cons? e /\ Nil? (enum_tail e)))
(v: (enum_key e -> Tot Type))
: Tot (dep_enum_destr e v)
= match e with
| ((k, _) :: _) ->
fun
(v_eq: ((k: enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: enum_key e) -> Tot (v k)))
(k' : enum_key e) ->
[@inline_let]
let _ = r_reflexive_t_elim (v k') (v_eq k') (v_eq_refl k') in
[@inline_let]
let _ = r_transitive_t_elim (v k') (v_eq k') (v_eq_trans k') in
[@inline_let]
let y : v k' = f k in
(y <: (y: v k' { v_eq k' y (f k') } ))
(* Destructor from the representation *)
let maybe_enum_key_of_repr_not_in (#key #repr: eqtype) (e: enum key repr) (l: list (key * repr)) (x: repr) : GTot Type0 =
(~ (L.mem x (L.map snd l)))
let list_rev_cons
(#t: Type)
(a: t)
(q: list t)
: Lemma
(L.rev (a :: q) == L.rev q `L.append` [a])
= L.rev_rev' (a :: q);
L.rev_rev' q
let list_append_rev_cons (#t: Type) (l1: list t) (x: t) (l2: list t) : Lemma
(L.append (L.rev l1) (x :: l2) == L.append (L.rev (x :: l1)) l2)
= list_rev_cons x l1;
L.append_assoc (L.rev l1) [x] l2
let rec assoc_append_flip_l_intro
(#key #repr: eqtype)
(l1 l2: list (key * repr))
(y: repr)
(x: key)
: Lemma
(requires (L.noRepeats (L.map snd (L.append l1 l2)) /\ L.assoc y (L.map flip l2) == Some x))
(ensures (L.assoc y (L.map flip (l1 `L.append` l2)) == Some x))
= match l1 with
| [] -> ()
| (_, r') :: q ->
L.assoc_mem y (L.map flip l2);
map_fst_flip l2;
L.map_append snd l1 l2;
L.noRepeats_append_elim (L.map snd l1) (L.map snd l2);
assoc_append_flip_l_intro q l2 y x
inline_for_extraction
let maybe_enum_destr_t'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let maybe_enum_destr_t
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot Type
= (eq: (t -> t -> GTot Type0)) ->
(ift: if_combinator t eq) ->
(eq_refl: r_reflexive_t _ eq) ->
(eq_trans: r_transitive_t _ eq) ->
(f: ((x: maybe_enum_key e) -> Tot t)) ->
(x: repr) ->
Tot (y: t { eq y (f (maybe_enum_key_of_repr e x)) } )
inline_for_extraction
let destr_maybe_total_enum_repr
(#t: Type)
(#key #repr: eqtype)
(e: total_enum key repr)
(destr: maybe_enum_destr_t t e)
(eq: (t -> t -> GTot Type0))
(ift: if_combinator t eq)
(eq_refl: r_reflexive_t _ eq)
(eq_trans: r_transitive_t _ eq)
(f: ((x: maybe_total_enum_key e) -> Tot t))
(x: repr)
: Tot (y: t { eq y (f (maybe_total_enum_key_of_repr e x)) } )
= destr eq ift eq_refl eq_trans (fun y -> f (total_of_maybe_enum_key e y)) x
inline_for_extraction
let maybe_enum_destr_t_intro
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(f: maybe_enum_destr_t' t e [] e ())
: Tot (maybe_enum_destr_t t e)
= f
let maybe_enum_key_of_repr_not_in_cons
(#key #repr: eqtype)
(e: enum key repr)
(k: key)
(r: repr)
(l: list (key * repr))
(x: repr)
: Lemma
(requires (maybe_enum_key_of_repr_not_in e l x /\ x <> r))
(ensures (maybe_enum_key_of_repr_not_in e ((k, r) :: l) x))
= ()
[@Norm]
inline_for_extraction
let list_hd
(#t: Type)
(l: list t { Cons? l } )
= match l with
| a :: _ -> a
[@Norm]
inline_for_extraction
let list_tl
(#t: Type)
(l: list t { Cons? l } )
= match l with
| _ :: q -> q
inline_for_extraction
let maybe_enum_destr_cons
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (maybe_enum_destr_t' t e (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
ift
(x = r)
(fun h -> f (Known k))
(fun h -> g eq ift eq_refl eq_trans f x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
let rec list_rev_map
(#t1 #t2: Type)
(f: t1 -> Tot t2)
(l: list t1)
: Lemma
(L.rev (L.map f l) == L.map f (L.rev l))
= match l with
| [] -> ()
| a :: q ->
list_rev_cons a q;
list_rev_cons (f a) (L.map f q);
list_rev_map f q;
L.map_append f (L.rev q) [a]
inline_for_extraction
let maybe_enum_destr_nil
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (maybe_enum_destr_t' t e l1 l2 u1)
= fun (eq: (t -> t -> GTot Type0)) (ift: if_combinator t eq) (eq_refl: r_reflexive_t _ eq) (eq_trans: r_transitive_t _ eq) (f: (maybe_enum_key e -> Tot t)) ->
[@inline_let]
let _ = r_reflexive_t_elim _ _ eq_refl in
[@inline_let]
let _ = r_transitive_t_elim _ _ eq_trans in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) -> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
f (Unknown x)
) <: (y: t { eq y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_maybe_enum_destr'
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
(l1: list (key * repr))
(l2: list (key * repr))
(u: squash (e == L.rev l1 `L.append` l2))
: Tot (maybe_enum_destr_t' t e l1 l2 u)
(decreases l2)
= match l2 with
| [] -> maybe_enum_destr_nil t e l1 l2 u
| _ ->
[@inline_let]
let _ = list_append_rev_cons l1 (list_hd l2) (list_tl l2) in
maybe_enum_destr_cons t e l1 l2 u (mk_maybe_enum_destr' t e (list_hd l2 :: l1) (list_tl l2) u)
[@Norm]
let mk_maybe_enum_destr
(t: Type)
(#key #repr: eqtype)
(e: enum key repr)
: Tot (maybe_enum_destr_t t e)
= maybe_enum_destr_t_intro t e (mk_maybe_enum_destr' t e [] e ())
(* dependent representation-based destructor *)
inline_for_extraction
let dep_maybe_enum_destr_t
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1 l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot Type
= (v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0)) ->
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k)))) ->
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k)))) ->
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k)))) ->
(f: ((k: maybe_enum_key e) -> Tot (v k))) ->
(r: repr { maybe_enum_key_of_repr_not_in e l1 r } ) ->
Tot (y: v (maybe_enum_key_of_repr e r) { v_eq (maybe_enum_key_of_repr e r) y (f (maybe_enum_key_of_repr e r)) } )
inline_for_extraction
let dep_maybe_enum_destr_t_intro
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(d: dep_maybe_enum_destr_t' e v [] e ())
: Tot (dep_maybe_enum_destr_t e v)
= d
inline_for_extraction
let dep_maybe_enum_destr_cons
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Cons? l2 /\ e == L.append (L.rev l1) l2))
(g: (dep_maybe_enum_destr_t' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2))))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
->
match list_hd l2 with
| (k, r) ->
[@inline_let]
let _ : squash (L.mem k (L.map fst e)) =
L.append_mem (L.map fst (L.rev l1)) (L.map fst l2) k;
L.map_append fst (L.rev l1) (l2);
()
in
[@inline_let]
let (_ : squash (maybe_enum_key_of_repr e r == Known k)) =
L.append_mem (L.map snd (L.rev l1)) (L.map snd (l2)) r;
L.map_append snd (L.rev l1) (l2);
assoc_append_flip_l_intro (L.rev l1) (l2) r k;
()
in
fun (x: repr { maybe_enum_key_of_repr_not_in e l1 x } ) ->
//NS: y is linear in the continuation after erasure; inline it
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) =
v_if
(maybe_enum_key_of_repr e x) // TODO: Since we cannot make this argument ghost, we need to make the user aware of the fact that this argument must not be extracted.
(x = r)
(fun h -> f (Known k))
(fun h ->
g v_eq v_if v_eq_refl v_eq_trans f x)
in
[@inline_let]
let _ : squash (v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x))) =
if x = r
then ()
else v_eq_trans (maybe_enum_key_of_repr e x) y (g v_eq v_if v_eq_refl v_eq_trans f x) (f (maybe_enum_key_of_repr e x))
in
(y <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
inline_for_extraction
let dep_maybe_enum_destr_nil
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (Nil? l2 /\ e == L.append (L.rev l1) []))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
= fun
(v_eq: ((k: maybe_enum_key e) -> v k -> v k -> GTot Type0))
(v_if: ((k: maybe_enum_key e) -> Tot (if_combinator (v k) (v_eq k))))
(v_eq_refl: ((k: maybe_enum_key e) -> Tot (r_reflexive_t _ (v_eq k))))
(v_eq_trans: ((k: maybe_enum_key e) -> Tot (r_transitive_t _ (v_eq k))))
(f: ((k: maybe_enum_key e) -> Tot (v k)))
(x: repr { maybe_enum_key_of_repr_not_in e l1 x } )
-> ((
L.append_l_nil (L.rev l1);
list_rev_map snd l1;
L.rev_mem (L.map snd l1) x;
assert (Unknown x == maybe_enum_key_of_repr e x);
//NS: y is linear in the continuation after erasure
[@inline_let]
let y : v (maybe_enum_key_of_repr e x) = f (Unknown x) in
[@inline_let]
let _ = v_eq_refl (maybe_enum_key_of_repr e x) (f (maybe_enum_key_of_repr e x)) in
y
) <: (y: v (maybe_enum_key_of_repr e x) { v_eq (maybe_enum_key_of_repr e x) y (f (maybe_enum_key_of_repr e x)) } ))
[@Norm]
let rec mk_dep_maybe_enum_destr'
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
(l1: list (key * repr))
(l2: list (key * repr))
(u1: squash (e == L.append (L.rev l1) l2))
: Tot (dep_maybe_enum_destr_t' e v l1 l2 u1)
(decreases l2)
= match l2 with
| [] -> dep_maybe_enum_destr_nil e v l1 l2 u1
| _ -> dep_maybe_enum_destr_cons e v l1 l2 u1 (mk_dep_maybe_enum_destr' e v (list_hd l2 :: l1) (list_tl l2) (list_append_rev_cons l1 (list_hd l2) (list_tl l2)))
[@Norm]
let mk_dep_maybe_enum_destr
(#key #repr: eqtype)
(e: enum key repr)
(v: (maybe_enum_key e -> Tot Type))
= dep_maybe_enum_destr_t_intro e v (mk_dep_maybe_enum_destr' e v [] e ())
(* Eliminators and destructors for verification purposes *)
let rec list_forallp (#t: Type) (p: t -> GTot Type0) (l: list t) : GTot Type0 =
match l with
| [] -> True
| a :: q -> p a /\ list_forallp p q
let rec list_forallp_mem (#t: eqtype) (p: t -> GTot Type0) (l: list t) : Lemma
(list_forallp p l <==> (forall x . L.mem x l ==> p x))
= match l with
| [] -> ()
| _ :: q -> list_forallp_mem p q
inline_for_extraction
let destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: maybe_enum_key e -> Tot Type)
(f_known: (
(x: key) ->
(u: squash (list_mem x (list_map fst e))) ->
Tot (f (Known x))
))
(f_unknown: (
(x: value) ->
(u: squash (list_mem x (list_map snd e) == false)) ->
Tot (f (Unknown x))
))
(x: maybe_enum_key e) | false | false | LowParse.Spec.Enum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val destruct_maybe_enum_key
(#key #value: eqtype)
(e: enum key value)
(f: (maybe_enum_key e -> Tot Type))
(f_known: (x: key -> u: squash (list_mem x (list_map fst e)) -> Tot (f (Known x))))
(f_unknown:
(x: value -> u: squash (list_mem x (list_map snd e) == false) -> Tot (f (Unknown x))))
(x: maybe_enum_key e)
: Tot (f x) | [] | LowParse.Spec.Enum.destruct_maybe_enum_key | {
"file_name": "src/lowparse/LowParse.Spec.Enum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
e: LowParse.Spec.Enum.enum key value ->
f: (_: LowParse.Spec.Enum.maybe_enum_key e -> Type) ->
f_known:
(
x: key ->
u482:
Prims.squash (LowParse.Spec.Enum.list_mem x
(LowParse.Spec.Enum.list_map FStar.Pervasives.Native.fst e))
-> f (LowParse.Spec.Enum.Known x)) ->
f_unknown:
(
x: value ->
u484:
Prims.squash (LowParse.Spec.Enum.list_mem x
(LowParse.Spec.Enum.list_map FStar.Pervasives.Native.snd e) ==
false)
-> f (LowParse.Spec.Enum.Unknown x)) ->
x: LowParse.Spec.Enum.maybe_enum_key e
-> f x | {
"end_col": 33,
"end_line": 1179,
"start_col": 2,
"start_line": 1177
} |
FStar.Pervasives.Lemma | val fmul5_lemma: a:felem5 -> b:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64) /\
felem_fits5 b (64,64,64,64,64))
(ensures (let res = fmul5 a b in
as_nat5 res % S.prime == as_nat5 a * as_nat5 b % S.prime /\
felem_fits5 res (1,1,1,1,2))) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Lemmas5",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas4",
"short_module": "L4"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fmul5_lemma a b =
let (a0,a1,a2,a3,a4) = a in
let (b0,b1,b2,b3,b4) = b in
let r = u64 0x1000003D10 in
let d0 = mul64_wide a0 b3
+. mul64_wide a1 b2
+. mul64_wide a2 b1
+. mul64_wide a3 b0 in
lemma_four_mul64_wide a0 a1 a2 a3 b0 b1 b2 b3;
assert (v d0 = v a0 * v b3 + v a1 * v b2 + v a2 * v b1 + v a3 * v b0);
assert (v d0 <= 16384 * (max52 * max52));
let c0 = mul64_wide a4 b4 in
lemma_bound_mul64_wide 64 64 max48 max48 a4 b4;
assert (v c0 = v a4 * v b4);
assert (v c0 <= 4096 * (max48 * max48));
let d1 = d0 +. mul64_wide r (to_u64 c0) in let c1 = to_u64 (c0 >>. 64ul) in
lemma_bound_add_mul64_wide_r 16384 d0 c0;
assert (v d1 = v d0 + v r * (v c0 % pow2 64));
assert (v d1 <= 16385 * (max52 * max52));
lemma_bound_rsh64_to c0;
assert (v c1 = v c0 / pow2 64);
lemma_bound_c0 c0;
assert (v c1 <= pow2 44);
let t3 = to_u64 d1 &. mask52 in let d2 = d1 >>. 52ul in
lemma_bound_mask52_rsh52 16385 d1;
assert (v t3 = v d1 % pow2 52);
assert (felem_fits1 t3 1);
assert (v d2 = v d1 / pow2 52);
assert (v d2 <= 16385 * max52);
let d3 = d2
+. mul64_wide a0 b4
+. mul64_wide a1 b3
+. mul64_wide a2 b2
+. mul64_wide a3 b1
+. mul64_wide a4 b0 in
lemma_add_five_mul64_wide 16385 d2 a0 a1 a2 a3 a4 b0 b1 b2 b3 b4;
assert (v d3 == v d2 + v a0 * v b4 + v a1 * v b3 + v a2 * v b2 + v a3 * v b1 + v a4 * v b0);
assert (v d3 <= 12801 * (max52 * max52));
let d4 = d3 +. mul64_wide (r <<. 12ul) c1 in
lemma_bound_add_mul64_wide_r_lsh12 12801 d3 c1;
assert (v d4 == v d3 + v r * pow2 12 * v c1);
assert (v d4 <= 12802 * (max52 * max52));
let t4 = to_u64 d4 &. mask52 in let d5 = d4 >>. 52ul in
lemma_bound_mask52_rsh52 12802 d4;
assert (v t4 = v d4 % pow2 52);
assert (felem_fits1 t4 1);
assert (v d5 = v d4 / pow2 52);
assert (v d5 <= 12802 * max52);
let tx = t4 >>. 48ul in let t4' = t4 &. mask48 in
lemma_bound_mask48_rsh48 t4;
assert (v tx = v t4 / pow2 48);
assert (v tx < pow2 4);
assert (v t4' = v t4 % pow2 48);
assert (felem_fits_last1 t4' 1);
let c2 = mul64_wide a0 b0 in
lemma_bound_mul64_wide 64 64 max52 max52 a0 b0;
assert (v c2 = v a0 * v b0);
assert (v c2 <= 4096 * (max52 * max52));
let d6 = d5
+. mul64_wide a1 b4
+. mul64_wide a2 b3
+. mul64_wide a3 b2
+. mul64_wide a4 b1 in
lemma_add_four_mul64_wide 12802 d5 a1 a2 a3 a4 b1 b2 b3 b4;
assert (v d6 == v d5 + v a1 * v b4 + v a2 * v b3 + v a3 * v b2 + v a4 * v b1);
assert (v d6 <= 8705 * (max52 * max52));
let u0 = to_u64 d6 &. mask52 in let d7 = d6 >>. 52ul in
lemma_bound_mask52_rsh52 8705 d6;
assert (v u0 = v d6 % pow2 52);
assert (felem_fits1 u0 1);
assert (v d7 = v d6 / pow2 52);
assert (v d7 <= 8705 * max52);
let u0' = tx |. (u0 <<. 4ul) in
lemma_tx_logor_u0_lsh4 tx u0;
assert (v u0' == v tx + v u0 * pow2 4);
assert (v u0' < pow2 56);
let c3 = c2 +. mul64_wide u0' (r >>. 4ul) in
lemma_bound_add_mul64_wide_r_rsh4 4096 c2 u0';
assert (v c3 = v c2 + v u0' * (v r / pow2 4));
assert (v c3 <= 4097 * (max52 * max52));
let r0 = to_u64 c3 &. mask52 in let c4 = c3 >>. 52ul in
lemma_bound_mask52_rsh52 4097 c3;
assert (v r0 = v c3 % pow2 52);
assert (felem_fits1 r0 1);
assert (v c4 = v c3 / pow2 52);
assert (v c4 <= 4097 * max52);
let c5 = c4
+. mul64_wide a0 b1
+. mul64_wide a1 b0 in
lemma_add_two_mul64_wide52 4097 c4 a0 a1 b0 b1;
assert (v c5 = v c4 + v a0 * v b1 + v a1 * v b0);
assert (v c5 <= 8193 * (max52 * max52));
let d8 = d7
+. mul64_wide a2 b4
+. mul64_wide a3 b3
+. mul64_wide a4 b2 in
lemma_add_three_mul64_wide 8705 d7 a2 a3 a4 b2 b3 b4;
assert (v d8 = v d7 + v a2 * v b4 + v a3 * v b3 + v a4 * v b2);
assert (v d8 <= 4609 * (max52 * max52));
let c6 = c5 +. mul64_wide (to_u64 d8 &. mask52) r in let d9 = d8 >>. 52ul in
lemma_bound_add_mul64_wide_r_mask52 8193 d8 c5;
assert (v d9 = v d8 / pow2 52);
assert (v d9 <= 8193 * max52);
assert (v c6 = v c5 + v d8 % pow2 52 * v r);
assert (v c6 <= 8194 * (max52 * max52));
let r1 = to_u64 c6 &. mask52 in let c7 = c6 >>. 52ul in
lemma_bound_mask52_rsh52 8194 c6;
assert (v r1 = v c6 % pow2 52);
assert (felem_fits1 r1 1);
assert (v c7 = v c6 / pow2 52);
assert (v c7 <= 8194 * max52);
let c8 = c7
+. mul64_wide a0 b2
+. mul64_wide a1 b1
+. mul64_wide a2 b0 in
lemma_add_three_mul64_wide52 8194 c7 a0 a1 a2 b0 b1 b2;
assert (v c8 == v c7 + v a0 * v b2 + v a1 * v b1 + v a2 * v b0);
assert (v c8 <= 12289 * (max52 * max52));
let d10 = d9
+. mul64_wide a3 b4
+. mul64_wide a4 b3 in
lemma_add_two_mul64_wide 8193 d9 a3 a4 b3 b4;
assert (v d10 == v d9 + v a3 * v b4 + v a4 * v b3);
assert (v d10 <= 513 * (max52 * max52));
let c9 = c8 +. mul64_wide r (to_u64 d10) in let d11 = to_u64 (d10 >>. 64ul) in
lemma_bound_add_mul64_wide_r 12289 c8 d10;
assert (v c9 = v c8 + v r * (v d10 % pow2 64));
assert (v c9 <= 12290 * (max52 * max52));
lemma_bound_rsh64_to d10;
assert (v d11 = v d10 / pow2 64);
lemma_bound_d10 d10;
assert (v d11 < pow2 50);
let r2 = to_u64 c9 &. mask52 in let c10 = c9 >>. 52ul in
lemma_bound_mask52_rsh52 12290 c9;
assert (v r2 = v c9 % pow2 52);
assert (felem_fits1 r2 1);
assert (v c10 = v c9 / pow2 52);
assert (v c10 <= 12290 * max52);
let c11 = c10 +. mul64_wide (r <<. 12ul) d11 +. to_u128 t3 in
lemma_bound_add_mul64_wide_r_lsh12_add 12290 c10 d11 t3;
assert (v c11 = v c10 + v r * pow2 12 * v d11 + v t3);
assert (v c11 < pow2 100);
let r3 = to_u64 c11 &. mask52 in let c12 = to_u64 (c11 >>. 52ul) in
lemma_bound_mask52_rsh52_sp c11;
assert (v r3 = v c11 % pow2 52);
assert (felem_fits1 r3 1);
assert (v c12 = v c11 / pow2 52);
assert (v c12 < pow2 48);
let r4 = c12 +. t4' in
lemma_mod_add_last c12 t4';
assert (v r4 = v c12 + v t4');
assert (felem_fits_last1 r4 2);
let res = (r0,r1,r2,r3,r4) in
assert (res == fmul5 a b);
assert (felem_fits5 res (1,1,1,1,2));
L4.lemma_fmul_simplify (v r0) (v r1) (v r2) (v r3) (v r4)
(v c3) (v c6) (v c9) (v c11) (v d4) (v d8) (v d10) (v d11)
(v t3) (v a0) (v a1) (v a2) (v a3) (v a4) (v b0) (v b1) (v b2) (v b3) (v b4) | val fmul5_lemma: a:felem5 -> b:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64) /\
felem_fits5 b (64,64,64,64,64))
(ensures (let res = fmul5 a b in
as_nat5 res % S.prime == as_nat5 a * as_nat5 b % S.prime /\
felem_fits5 res (1,1,1,1,2)))
let fmul5_lemma a b = | false | null | true | let a0, a1, a2, a3, a4 = a in
let b0, b1, b2, b3, b4 = b in
let r = u64 0x1000003D10 in
let d0 = mul64_wide a0 b3 +. mul64_wide a1 b2 +. mul64_wide a2 b1 +. mul64_wide a3 b0 in
lemma_four_mul64_wide a0 a1 a2 a3 b0 b1 b2 b3;
assert (v d0 = v a0 * v b3 + v a1 * v b2 + v a2 * v b1 + v a3 * v b0);
assert (v d0 <= 16384 * (max52 * max52));
let c0 = mul64_wide a4 b4 in
lemma_bound_mul64_wide 64 64 max48 max48 a4 b4;
assert (v c0 = v a4 * v b4);
assert (v c0 <= 4096 * (max48 * max48));
let d1 = d0 +. mul64_wide r (to_u64 c0) in
let c1 = to_u64 (c0 >>. 64ul) in
lemma_bound_add_mul64_wide_r 16384 d0 c0;
assert (v d1 = v d0 + v r * (v c0 % pow2 64));
assert (v d1 <= 16385 * (max52 * max52));
lemma_bound_rsh64_to c0;
assert (v c1 = v c0 / pow2 64);
lemma_bound_c0 c0;
assert (v c1 <= pow2 44);
let t3 = to_u64 d1 &. mask52 in
let d2 = d1 >>. 52ul in
lemma_bound_mask52_rsh52 16385 d1;
assert (v t3 = v d1 % pow2 52);
assert (felem_fits1 t3 1);
assert (v d2 = v d1 / pow2 52);
assert (v d2 <= 16385 * max52);
let d3 =
d2 +. mul64_wide a0 b4 +. mul64_wide a1 b3 +. mul64_wide a2 b2 +. mul64_wide a3 b1 +.
mul64_wide a4 b0
in
lemma_add_five_mul64_wide 16385 d2 a0 a1 a2 a3 a4 b0 b1 b2 b3 b4;
assert (v d3 == v d2 + v a0 * v b4 + v a1 * v b3 + v a2 * v b2 + v a3 * v b1 + v a4 * v b0);
assert (v d3 <= 12801 * (max52 * max52));
let d4 = d3 +. mul64_wide (r <<. 12ul) c1 in
lemma_bound_add_mul64_wide_r_lsh12 12801 d3 c1;
assert (v d4 == v d3 + (v r * pow2 12) * v c1);
assert (v d4 <= 12802 * (max52 * max52));
let t4 = to_u64 d4 &. mask52 in
let d5 = d4 >>. 52ul in
lemma_bound_mask52_rsh52 12802 d4;
assert (v t4 = v d4 % pow2 52);
assert (felem_fits1 t4 1);
assert (v d5 = v d4 / pow2 52);
assert (v d5 <= 12802 * max52);
let tx = t4 >>. 48ul in
let t4' = t4 &. mask48 in
lemma_bound_mask48_rsh48 t4;
assert (v tx = v t4 / pow2 48);
assert (v tx < pow2 4);
assert (v t4' = v t4 % pow2 48);
assert (felem_fits_last1 t4' 1);
let c2 = mul64_wide a0 b0 in
lemma_bound_mul64_wide 64 64 max52 max52 a0 b0;
assert (v c2 = v a0 * v b0);
assert (v c2 <= 4096 * (max52 * max52));
let d6 = d5 +. mul64_wide a1 b4 +. mul64_wide a2 b3 +. mul64_wide a3 b2 +. mul64_wide a4 b1 in
lemma_add_four_mul64_wide 12802 d5 a1 a2 a3 a4 b1 b2 b3 b4;
assert (v d6 == v d5 + v a1 * v b4 + v a2 * v b3 + v a3 * v b2 + v a4 * v b1);
assert (v d6 <= 8705 * (max52 * max52));
let u0 = to_u64 d6 &. mask52 in
let d7 = d6 >>. 52ul in
lemma_bound_mask52_rsh52 8705 d6;
assert (v u0 = v d6 % pow2 52);
assert (felem_fits1 u0 1);
assert (v d7 = v d6 / pow2 52);
assert (v d7 <= 8705 * max52);
let u0' = tx |. (u0 <<. 4ul) in
lemma_tx_logor_u0_lsh4 tx u0;
assert (v u0' == v tx + v u0 * pow2 4);
assert (v u0' < pow2 56);
let c3 = c2 +. mul64_wide u0' (r >>. 4ul) in
lemma_bound_add_mul64_wide_r_rsh4 4096 c2 u0';
assert (v c3 = v c2 + v u0' * (v r / pow2 4));
assert (v c3 <= 4097 * (max52 * max52));
let r0 = to_u64 c3 &. mask52 in
let c4 = c3 >>. 52ul in
lemma_bound_mask52_rsh52 4097 c3;
assert (v r0 = v c3 % pow2 52);
assert (felem_fits1 r0 1);
assert (v c4 = v c3 / pow2 52);
assert (v c4 <= 4097 * max52);
let c5 = c4 +. mul64_wide a0 b1 +. mul64_wide a1 b0 in
lemma_add_two_mul64_wide52 4097 c4 a0 a1 b0 b1;
assert (v c5 = v c4 + v a0 * v b1 + v a1 * v b0);
assert (v c5 <= 8193 * (max52 * max52));
let d8 = d7 +. mul64_wide a2 b4 +. mul64_wide a3 b3 +. mul64_wide a4 b2 in
lemma_add_three_mul64_wide 8705 d7 a2 a3 a4 b2 b3 b4;
assert (v d8 = v d7 + v a2 * v b4 + v a3 * v b3 + v a4 * v b2);
assert (v d8 <= 4609 * (max52 * max52));
let c6 = c5 +. mul64_wide (to_u64 d8 &. mask52) r in
let d9 = d8 >>. 52ul in
lemma_bound_add_mul64_wide_r_mask52 8193 d8 c5;
assert (v d9 = v d8 / pow2 52);
assert (v d9 <= 8193 * max52);
assert (v c6 = v c5 + (v d8 % pow2 52) * v r);
assert (v c6 <= 8194 * (max52 * max52));
let r1 = to_u64 c6 &. mask52 in
let c7 = c6 >>. 52ul in
lemma_bound_mask52_rsh52 8194 c6;
assert (v r1 = v c6 % pow2 52);
assert (felem_fits1 r1 1);
assert (v c7 = v c6 / pow2 52);
assert (v c7 <= 8194 * max52);
let c8 = c7 +. mul64_wide a0 b2 +. mul64_wide a1 b1 +. mul64_wide a2 b0 in
lemma_add_three_mul64_wide52 8194 c7 a0 a1 a2 b0 b1 b2;
assert (v c8 == v c7 + v a0 * v b2 + v a1 * v b1 + v a2 * v b0);
assert (v c8 <= 12289 * (max52 * max52));
let d10 = d9 +. mul64_wide a3 b4 +. mul64_wide a4 b3 in
lemma_add_two_mul64_wide 8193 d9 a3 a4 b3 b4;
assert (v d10 == v d9 + v a3 * v b4 + v a4 * v b3);
assert (v d10 <= 513 * (max52 * max52));
let c9 = c8 +. mul64_wide r (to_u64 d10) in
let d11 = to_u64 (d10 >>. 64ul) in
lemma_bound_add_mul64_wide_r 12289 c8 d10;
assert (v c9 = v c8 + v r * (v d10 % pow2 64));
assert (v c9 <= 12290 * (max52 * max52));
lemma_bound_rsh64_to d10;
assert (v d11 = v d10 / pow2 64);
lemma_bound_d10 d10;
assert (v d11 < pow2 50);
let r2 = to_u64 c9 &. mask52 in
let c10 = c9 >>. 52ul in
lemma_bound_mask52_rsh52 12290 c9;
assert (v r2 = v c9 % pow2 52);
assert (felem_fits1 r2 1);
assert (v c10 = v c9 / pow2 52);
assert (v c10 <= 12290 * max52);
let c11 = c10 +. mul64_wide (r <<. 12ul) d11 +. to_u128 t3 in
lemma_bound_add_mul64_wide_r_lsh12_add 12290 c10 d11 t3;
assert (v c11 = v c10 + (v r * pow2 12) * v d11 + v t3);
assert (v c11 < pow2 100);
let r3 = to_u64 c11 &. mask52 in
let c12 = to_u64 (c11 >>. 52ul) in
lemma_bound_mask52_rsh52_sp c11;
assert (v r3 = v c11 % pow2 52);
assert (felem_fits1 r3 1);
assert (v c12 = v c11 / pow2 52);
assert (v c12 < pow2 48);
let r4 = c12 +. t4' in
lemma_mod_add_last c12 t4';
assert (v r4 = v c12 + v t4');
assert (felem_fits_last1 r4 2);
let res = (r0, r1, r2, r3, r4) in
assert (res == fmul5 a b);
assert (felem_fits5 res (1, 1, 1, 1, 2));
L4.lemma_fmul_simplify (v r0) (v r1) (v r2) (v r3) (v r4) (v c3) (v c6) (v c9) (v c11) (v d4) (v d8)
(v d10) (v d11) (v t3) (v a0) (v a1) (v a2) (v a3) (v a4) (v b0) (v b1) (v b2) (v b3) (v b4) | {
"checked_file": "Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.Field52.Lemmas5.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas4.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.Field52.Lemmas3.fst"
} | [
"lemma"
] | [
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Lib.IntTypes.uint64",
"Hacl.Spec.K256.Field52.Lemmas4.lemma_fmul_simplify",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.U128",
"Prims.unit",
"Prims._assert",
"Hacl.Spec.K256.Field52.Definitions.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Prims.eq2",
"FStar.Pervasives.Native.tuple5",
"Hacl.Spec.K256.Field52.fmul5",
"Lib.IntTypes.int_t",
"Prims.b2t",
"Hacl.Spec.K256.Field52.Definitions.felem_fits_last1",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Addition",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_mod_add_last",
"Lib.IntTypes.op_Plus_Dot",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Division",
"Hacl.Spec.K256.Field52.Definitions.felem_fits1",
"Prims.op_Modulus",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_mask52_rsh52_sp",
"Lib.IntTypes.to_u64",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Amp_Dot",
"Hacl.Spec.K256.Field52.Definitions.mask52",
"FStar.Mul.op_Star",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_add_mul64_wide_r_lsh12_add",
"Lib.IntTypes.mul64_wide",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.to_u128",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.K256.Field52.Definitions.max52",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_mask52_rsh52",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_d10",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_rsh64_to",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_add_mul64_wide_r",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_add_two_mul64_wide",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_add_three_mul64_wide52",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_add_mul64_wide_r_mask52",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_add_three_mul64_wide",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_add_two_mul64_wide52",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_add_mul64_wide_r_rsh4",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_tx_logor_u0_lsh4",
"Lib.IntTypes.op_Bar_Dot",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_add_four_mul64_wide",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_mul64_wide",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_mask48_rsh48",
"Hacl.Spec.K256.Field52.Definitions.mask48",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_add_mul64_wide_r_lsh12",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_add_five_mul64_wide",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_c0",
"Hacl.Spec.K256.Field52.Definitions.max48",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_four_mul64_wide",
"Lib.IntTypes.range",
"Lib.IntTypes.u64"
] | [] | module Hacl.Spec.K256.Field52.Lemmas3
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module L4 = Hacl.Spec.K256.Field52.Lemmas4
open Hacl.Spec.K256.Field52.Lemmas5
#set-options "--z3rlimit 150 --fuel 0 --ifuel 0"
val fmul5_lemma: a:felem5 -> b:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64) /\
felem_fits5 b (64,64,64,64,64))
(ensures (let res = fmul5 a b in
as_nat5 res % S.prime == as_nat5 a * as_nat5 b % S.prime /\
felem_fits5 res (1,1,1,1,2))) | false | false | Hacl.Spec.K256.Field52.Lemmas3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 150,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fmul5_lemma: a:felem5 -> b:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64) /\
felem_fits5 b (64,64,64,64,64))
(ensures (let res = fmul5 a b in
as_nat5 res % S.prime == as_nat5 a * as_nat5 b % S.prime /\
felem_fits5 res (1,1,1,1,2))) | [] | Hacl.Spec.K256.Field52.Lemmas3.fmul5_lemma | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.K256.Field52.Definitions.felem5 -> b: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.K256.Field52.Definitions.felem_fits5 a (64, 64, 64, 64, 64) /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 b (64, 64, 64, 64, 64))
(ensures
(let res = Hacl.Spec.K256.Field52.fmul5 a b in
Hacl.Spec.K256.Field52.Definitions.as_nat5 res % Spec.K256.PointOps.prime ==
Hacl.Spec.K256.Field52.Definitions.as_nat5 a *
Hacl.Spec.K256.Field52.Definitions.as_nat5 b %
Spec.K256.PointOps.prime /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 res (1, 1, 1, 1, 2))) | {
"end_col": 80,
"end_line": 209,
"start_col": 21,
"start_line": 24
} |
FStar.Pervasives.Lemma | val fsqr5_lemma: a:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64))
(ensures (let res = fsqr5 a in
as_nat5 res % S.prime == as_nat5 a * as_nat5 a % S.prime /\
felem_fits5 res (1,1,1,1,2))) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Lemmas5",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.Field52.Lemmas4",
"short_module": "L4"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fsqr5_lemma a =
let (a0,a1,a2,a3,a4) = a in
let r = u64 0x1000003D10 in
let d0 = mul64_wide (a0 *. u64 2) a3 +. mul64_wide (a1 *. u64 2) a2 in
lemma_four_sqr64_wide a0 a1 a2 a3;
assert (v d0 = v a0 * v a3 + v a1 * v a2 + v a2 * v a1 + v a3 * v a0);
assert (v d0 <= 16384 * (max52 * max52));
let c0 = mul64_wide a4 a4 in
lemma_bound_mul64_wide 64 64 max48 max48 a4 a4;
assert (v c0 = v a4 * v a4);
assert (v c0 <= 4096 * (max48 * max48));
let d1 = d0 +. mul64_wide r (to_u64 c0) in let c1 = to_u64 (c0 >>. 64ul) in
lemma_bound_add_mul64_wide_r 16384 d0 c0;
assert (v d1 = v d0 + v r * (v c0 % pow2 64));
assert (v d1 <= 16385 * (max52 * max52));
lemma_bound_rsh64_to c0;
assert (v c1 = v c0 / pow2 64);
lemma_bound_c0 c0;
assert (v c1 <= pow2 44);
let t3 = to_u64 d1 &. mask52 in let d2 = d1 >>. 52ul in
lemma_bound_mask52_rsh52 16385 d1;
assert (v t3 = v d1 % pow2 52);
assert (felem_fits1 t3 1);
assert (v d2 = v d1 / pow2 52);
assert (v d2 <= 16385 * max52);
let d3 = d2
+. mul64_wide a0 (a4 *. u64 2)
+. mul64_wide (a1 *. u64 2) a3
+. mul64_wide a2 a2 in
lemma_add_five_sqr64_wide 16385 d2 a0 a1 a2 a3 a4;
assert (v d3 == v d2 + v a0 * v a4 + v a1 * v a3 + v a2 * v a2 + v a3 * v a1 + v a4 * v a0);
assert (v d3 <= 12801 * (max52 * max52));
let d4 = d3 +. mul64_wide (r <<. 12ul) c1 in
lemma_bound_add_mul64_wide_r_lsh12 12801 d3 c1;
assert (v d4 == v d3 + v r * pow2 12 * v c1);
assert (v d4 <= 12802 * (max52 * max52));
let t4 = to_u64 d4 &. mask52 in let d5 = d4 >>. 52ul in
lemma_bound_mask52_rsh52 12802 d4;
assert (v t4 = v d4 % pow2 52);
assert (felem_fits1 t4 1);
assert (v d5 = v d4 / pow2 52);
assert (v d5 <= 12802 * max52);
let tx = t4 >>. 48ul in let t4' = t4 &. mask48 in
lemma_bound_mask48_rsh48 t4;
assert (v tx = v t4 / pow2 48);
assert (v tx < pow2 4);
assert (v t4' = v t4 % pow2 48);
assert (felem_fits_last1 t4' 1);
let c2 = mul64_wide a0 a0 in
lemma_bound_mul64_wide 64 64 max52 max52 a0 a0;
assert (v c2 = v a0 * v a0);
assert (v c2 <= 4096 * (max52 * max52));
let d6 = d5
+. mul64_wide a1 (a4 *. u64 2)
+. mul64_wide (a2 *. u64 2) a3 in
lemma_add_four_sqr64_wide 12802 d5 a1 a2 a3 a4;
assert (v d6 == v d5 + v a1 * v a4 + v a2 * v a3 + v a3 * v a2 + v a4 * v a1);
assert (v d6 <= 8705 * (max52 * max52));
let u0 = to_u64 d6 &. mask52 in let d7 = d6 >>. 52ul in
lemma_bound_mask52_rsh52 8705 d6;
assert (v u0 = v d6 % pow2 52);
assert (felem_fits1 u0 1);
assert (v d7 = v d6 / pow2 52);
assert (v d7 <= 8705 * max52);
let u0' = tx |. (u0 <<. 4ul) in
lemma_tx_logor_u0_lsh4 tx u0;
assert (v u0' == v tx + v u0 * pow2 4);
assert (v u0' < pow2 56);
let c3 = c2 +. mul64_wide u0' (r >>. 4ul) in
lemma_bound_add_mul64_wide_r_rsh4 4096 c2 u0';
assert (v c3 = v c2 + v u0' * (v r / pow2 4));
assert (v c3 <= 4097 * (max52 * max52));
let r0 = to_u64 c3 &. mask52 in let c4 = c3 >>. 52ul in
lemma_bound_mask52_rsh52 4097 c3;
assert (v r0 = v c3 % pow2 52);
assert (felem_fits1 r0 1);
assert (v c4 = v c3 / pow2 52);
assert (v c4 <= 4097 * max52);
let c5 = c4 +. mul64_wide (a0 *. u64 2) a1 in
lemma_add_two_sqr64_wide52 4097 c4 a0 a1;
assert (v c5 = v c4 + v a0 * v a1 + v a1 * v a0);
assert (v c5 <= 8193 * (max52 * max52));
let d8 = d7
+. mul64_wide a2 (a4 *. u64 2)
+. mul64_wide a3 a3 in
lemma_add_three_sqr64_wide 8705 d7 a2 a3 a4;
assert (v d8 = v d7 + v a2 * v a4 + v a3 * v a3 + v a4 * v a2);
assert (v d8 <= 4609 * (max52 * max52));
let c6 = c5 +. mul64_wide (to_u64 d8 &. mask52) r in let d9 = d8 >>. 52ul in
lemma_bound_add_mul64_wide_r_mask52 8193 d8 c5;
assert (v d9 = v d8 / pow2 52);
assert (v d9 <= 8193 * max52);
assert (v c6 = v c5 + v d8 % pow2 52 * v r);
assert (v c6 <= 8194 * (max52 * max52));
let r1 = to_u64 c6 &. mask52 in let c7 = c6 >>. 52ul in
lemma_bound_mask52_rsh52 8194 c6;
assert (v r1 = v c6 % pow2 52);
assert (felem_fits1 r1 1);
assert (v c7 = v c6 / pow2 52);
assert (v c7 <= 8194 * max52);
let c8 = c7
+. mul64_wide (a0 *. u64 2) a2
+. mul64_wide a1 a1 in
lemma_add_three_sqr64_wide52 8194 c7 a0 a1 a2;
assert (v c8 == v c7 + v a0 * v a2 + v a1 * v a1 + v a2 * v a0);
assert (v c8 <= 12289 * (max52 * max52));
let d10 = d9
+. mul64_wide a3 (a4 *. u64 2) in
lemma_add_two_sqr64_wide 8193 d9 a3 a4;
assert (v d10 == v d9 + v a3 * v a4 + v a4 * v a3);
assert (v d10 <= 513 * (max52 * max52));
let c9 = c8 +. mul64_wide r (to_u64 d10) in let d11 = to_u64 (d10 >>. 64ul) in
lemma_bound_add_mul64_wide_r 12289 c8 d10;
assert (v c9 = v c8 + v r * (v d10 % pow2 64));
assert (v c9 <= 12290 * (max52 * max52));
lemma_bound_rsh64_to d10;
assert (v d11 = v d10 / pow2 64);
lemma_bound_d10 d10;
assert (v d11 < pow2 50);
let r2 = to_u64 c9 &. mask52 in let c10 = c9 >>. 52ul in
lemma_bound_mask52_rsh52 12290 c9;
assert (v r2 = v c9 % pow2 52);
assert (felem_fits1 r2 1);
assert (v c10 = v c9 / pow2 52);
assert (v c10 <= 12290 * max52);
let c11 = c10 +. mul64_wide (r <<. 12ul) d11 +. to_u128 t3 in
lemma_bound_add_mul64_wide_r_lsh12_add 12290 c10 d11 t3;
assert (v c11 = v c10 + v r * pow2 12 * v d11 + v t3);
assert (v c11 < pow2 100);
let r3 = to_u64 c11 &. mask52 in let c12 = to_u64 (c11 >>. 52ul) in
lemma_bound_mask52_rsh52_sp c11;
assert (v r3 = v c11 % pow2 52);
assert (felem_fits1 r3 1);
assert (v c12 = v c11 / pow2 52);
assert (v c12 < pow2 48);
let r4 = c12 +. t4' in
lemma_mod_add_last c12 t4';
assert (v r4 = v c12 + v t4');
assert (felem_fits_last1 r4 2);
let res = (r0,r1,r2,r3,r4) in
assert (res == fsqr5 a);
assert (felem_fits5 res (1,1,1,1,2));
L4.lemma_fmul_simplify (v r0) (v r1) (v r2) (v r3) (v r4)
(v c3) (v c6) (v c9) (v c11) (v d4) (v d8) (v d10) (v d11)
(v t3) (v a0) (v a1) (v a2) (v a3) (v a4) (v a0) (v a1) (v a2) (v a3) (v a4) | val fsqr5_lemma: a:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64))
(ensures (let res = fsqr5 a in
as_nat5 res % S.prime == as_nat5 a * as_nat5 a % S.prime /\
felem_fits5 res (1,1,1,1,2)))
let fsqr5_lemma a = | false | null | true | let a0, a1, a2, a3, a4 = a in
let r = u64 0x1000003D10 in
let d0 = mul64_wide (a0 *. u64 2) a3 +. mul64_wide (a1 *. u64 2) a2 in
lemma_four_sqr64_wide a0 a1 a2 a3;
assert (v d0 = v a0 * v a3 + v a1 * v a2 + v a2 * v a1 + v a3 * v a0);
assert (v d0 <= 16384 * (max52 * max52));
let c0 = mul64_wide a4 a4 in
lemma_bound_mul64_wide 64 64 max48 max48 a4 a4;
assert (v c0 = v a4 * v a4);
assert (v c0 <= 4096 * (max48 * max48));
let d1 = d0 +. mul64_wide r (to_u64 c0) in
let c1 = to_u64 (c0 >>. 64ul) in
lemma_bound_add_mul64_wide_r 16384 d0 c0;
assert (v d1 = v d0 + v r * (v c0 % pow2 64));
assert (v d1 <= 16385 * (max52 * max52));
lemma_bound_rsh64_to c0;
assert (v c1 = v c0 / pow2 64);
lemma_bound_c0 c0;
assert (v c1 <= pow2 44);
let t3 = to_u64 d1 &. mask52 in
let d2 = d1 >>. 52ul in
lemma_bound_mask52_rsh52 16385 d1;
assert (v t3 = v d1 % pow2 52);
assert (felem_fits1 t3 1);
assert (v d2 = v d1 / pow2 52);
assert (v d2 <= 16385 * max52);
let d3 = d2 +. mul64_wide a0 (a4 *. u64 2) +. mul64_wide (a1 *. u64 2) a3 +. mul64_wide a2 a2 in
lemma_add_five_sqr64_wide 16385 d2 a0 a1 a2 a3 a4;
assert (v d3 == v d2 + v a0 * v a4 + v a1 * v a3 + v a2 * v a2 + v a3 * v a1 + v a4 * v a0);
assert (v d3 <= 12801 * (max52 * max52));
let d4 = d3 +. mul64_wide (r <<. 12ul) c1 in
lemma_bound_add_mul64_wide_r_lsh12 12801 d3 c1;
assert (v d4 == v d3 + (v r * pow2 12) * v c1);
assert (v d4 <= 12802 * (max52 * max52));
let t4 = to_u64 d4 &. mask52 in
let d5 = d4 >>. 52ul in
lemma_bound_mask52_rsh52 12802 d4;
assert (v t4 = v d4 % pow2 52);
assert (felem_fits1 t4 1);
assert (v d5 = v d4 / pow2 52);
assert (v d5 <= 12802 * max52);
let tx = t4 >>. 48ul in
let t4' = t4 &. mask48 in
lemma_bound_mask48_rsh48 t4;
assert (v tx = v t4 / pow2 48);
assert (v tx < pow2 4);
assert (v t4' = v t4 % pow2 48);
assert (felem_fits_last1 t4' 1);
let c2 = mul64_wide a0 a0 in
lemma_bound_mul64_wide 64 64 max52 max52 a0 a0;
assert (v c2 = v a0 * v a0);
assert (v c2 <= 4096 * (max52 * max52));
let d6 = d5 +. mul64_wide a1 (a4 *. u64 2) +. mul64_wide (a2 *. u64 2) a3 in
lemma_add_four_sqr64_wide 12802 d5 a1 a2 a3 a4;
assert (v d6 == v d5 + v a1 * v a4 + v a2 * v a3 + v a3 * v a2 + v a4 * v a1);
assert (v d6 <= 8705 * (max52 * max52));
let u0 = to_u64 d6 &. mask52 in
let d7 = d6 >>. 52ul in
lemma_bound_mask52_rsh52 8705 d6;
assert (v u0 = v d6 % pow2 52);
assert (felem_fits1 u0 1);
assert (v d7 = v d6 / pow2 52);
assert (v d7 <= 8705 * max52);
let u0' = tx |. (u0 <<. 4ul) in
lemma_tx_logor_u0_lsh4 tx u0;
assert (v u0' == v tx + v u0 * pow2 4);
assert (v u0' < pow2 56);
let c3 = c2 +. mul64_wide u0' (r >>. 4ul) in
lemma_bound_add_mul64_wide_r_rsh4 4096 c2 u0';
assert (v c3 = v c2 + v u0' * (v r / pow2 4));
assert (v c3 <= 4097 * (max52 * max52));
let r0 = to_u64 c3 &. mask52 in
let c4 = c3 >>. 52ul in
lemma_bound_mask52_rsh52 4097 c3;
assert (v r0 = v c3 % pow2 52);
assert (felem_fits1 r0 1);
assert (v c4 = v c3 / pow2 52);
assert (v c4 <= 4097 * max52);
let c5 = c4 +. mul64_wide (a0 *. u64 2) a1 in
lemma_add_two_sqr64_wide52 4097 c4 a0 a1;
assert (v c5 = v c4 + v a0 * v a1 + v a1 * v a0);
assert (v c5 <= 8193 * (max52 * max52));
let d8 = d7 +. mul64_wide a2 (a4 *. u64 2) +. mul64_wide a3 a3 in
lemma_add_three_sqr64_wide 8705 d7 a2 a3 a4;
assert (v d8 = v d7 + v a2 * v a4 + v a3 * v a3 + v a4 * v a2);
assert (v d8 <= 4609 * (max52 * max52));
let c6 = c5 +. mul64_wide (to_u64 d8 &. mask52) r in
let d9 = d8 >>. 52ul in
lemma_bound_add_mul64_wide_r_mask52 8193 d8 c5;
assert (v d9 = v d8 / pow2 52);
assert (v d9 <= 8193 * max52);
assert (v c6 = v c5 + (v d8 % pow2 52) * v r);
assert (v c6 <= 8194 * (max52 * max52));
let r1 = to_u64 c6 &. mask52 in
let c7 = c6 >>. 52ul in
lemma_bound_mask52_rsh52 8194 c6;
assert (v r1 = v c6 % pow2 52);
assert (felem_fits1 r1 1);
assert (v c7 = v c6 / pow2 52);
assert (v c7 <= 8194 * max52);
let c8 = c7 +. mul64_wide (a0 *. u64 2) a2 +. mul64_wide a1 a1 in
lemma_add_three_sqr64_wide52 8194 c7 a0 a1 a2;
assert (v c8 == v c7 + v a0 * v a2 + v a1 * v a1 + v a2 * v a0);
assert (v c8 <= 12289 * (max52 * max52));
let d10 = d9 +. mul64_wide a3 (a4 *. u64 2) in
lemma_add_two_sqr64_wide 8193 d9 a3 a4;
assert (v d10 == v d9 + v a3 * v a4 + v a4 * v a3);
assert (v d10 <= 513 * (max52 * max52));
let c9 = c8 +. mul64_wide r (to_u64 d10) in
let d11 = to_u64 (d10 >>. 64ul) in
lemma_bound_add_mul64_wide_r 12289 c8 d10;
assert (v c9 = v c8 + v r * (v d10 % pow2 64));
assert (v c9 <= 12290 * (max52 * max52));
lemma_bound_rsh64_to d10;
assert (v d11 = v d10 / pow2 64);
lemma_bound_d10 d10;
assert (v d11 < pow2 50);
let r2 = to_u64 c9 &. mask52 in
let c10 = c9 >>. 52ul in
lemma_bound_mask52_rsh52 12290 c9;
assert (v r2 = v c9 % pow2 52);
assert (felem_fits1 r2 1);
assert (v c10 = v c9 / pow2 52);
assert (v c10 <= 12290 * max52);
let c11 = c10 +. mul64_wide (r <<. 12ul) d11 +. to_u128 t3 in
lemma_bound_add_mul64_wide_r_lsh12_add 12290 c10 d11 t3;
assert (v c11 = v c10 + (v r * pow2 12) * v d11 + v t3);
assert (v c11 < pow2 100);
let r3 = to_u64 c11 &. mask52 in
let c12 = to_u64 (c11 >>. 52ul) in
lemma_bound_mask52_rsh52_sp c11;
assert (v r3 = v c11 % pow2 52);
assert (felem_fits1 r3 1);
assert (v c12 = v c11 / pow2 52);
assert (v c12 < pow2 48);
let r4 = c12 +. t4' in
lemma_mod_add_last c12 t4';
assert (v r4 = v c12 + v t4');
assert (felem_fits_last1 r4 2);
let res = (r0, r1, r2, r3, r4) in
assert (res == fsqr5 a);
assert (felem_fits5 res (1, 1, 1, 1, 2));
L4.lemma_fmul_simplify (v r0) (v r1) (v r2) (v r3) (v r4) (v c3) (v c6) (v c9) (v c11) (v d4) (v d8)
(v d10) (v d11) (v t3) (v a0) (v a1) (v a2) (v a3) (v a4) (v a0) (v a1) (v a2) (v a3) (v a4) | {
"checked_file": "Hacl.Spec.K256.Field52.Lemmas3.fst.checked",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.K256.Field52.Lemmas5.fst.checked",
"Hacl.Spec.K256.Field52.Lemmas4.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"Hacl.Spec.K256.Field52.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.Field52.Lemmas3.fst"
} | [
"lemma"
] | [
"Hacl.Spec.K256.Field52.Definitions.felem5",
"Lib.IntTypes.uint64",
"Hacl.Spec.K256.Field52.Lemmas4.lemma_fmul_simplify",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.U128",
"Prims.unit",
"Prims._assert",
"Hacl.Spec.K256.Field52.Definitions.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Prims.eq2",
"FStar.Pervasives.Native.tuple5",
"Hacl.Spec.K256.Field52.fsqr5",
"Lib.IntTypes.int_t",
"Prims.b2t",
"Hacl.Spec.K256.Field52.Definitions.felem_fits_last1",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Addition",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_mod_add_last",
"Lib.IntTypes.op_Plus_Dot",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Division",
"Hacl.Spec.K256.Field52.Definitions.felem_fits1",
"Prims.op_Modulus",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_mask52_rsh52_sp",
"Lib.IntTypes.to_u64",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Amp_Dot",
"Hacl.Spec.K256.Field52.Definitions.mask52",
"FStar.Mul.op_Star",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_add_mul64_wide_r_lsh12_add",
"Lib.IntTypes.mul64_wide",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.to_u128",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.K256.Field52.Definitions.max52",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_mask52_rsh52",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_d10",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_rsh64_to",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_add_mul64_wide_r",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_add_two_sqr64_wide",
"Lib.IntTypes.op_Star_Dot",
"Lib.IntTypes.u64",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_add_three_sqr64_wide52",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_add_mul64_wide_r_mask52",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_add_three_sqr64_wide",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_add_two_sqr64_wide52",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_add_mul64_wide_r_rsh4",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_tx_logor_u0_lsh4",
"Lib.IntTypes.op_Bar_Dot",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_add_four_sqr64_wide",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_mul64_wide",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_mask48_rsh48",
"Hacl.Spec.K256.Field52.Definitions.mask48",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_add_mul64_wide_r_lsh12",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_add_five_sqr64_wide",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_bound_c0",
"Hacl.Spec.K256.Field52.Definitions.max48",
"Hacl.Spec.K256.Field52.Lemmas5.lemma_four_sqr64_wide",
"Lib.IntTypes.range"
] | [] | module Hacl.Spec.K256.Field52.Lemmas3
open FStar.Mul
open Lib.IntTypes
module S = Spec.K256
include Hacl.Spec.K256.Field52.Definitions
include Hacl.Spec.K256.Field52
module L4 = Hacl.Spec.K256.Field52.Lemmas4
open Hacl.Spec.K256.Field52.Lemmas5
#set-options "--z3rlimit 150 --fuel 0 --ifuel 0"
val fmul5_lemma: a:felem5 -> b:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64) /\
felem_fits5 b (64,64,64,64,64))
(ensures (let res = fmul5 a b in
as_nat5 res % S.prime == as_nat5 a * as_nat5 b % S.prime /\
felem_fits5 res (1,1,1,1,2)))
let fmul5_lemma a b =
let (a0,a1,a2,a3,a4) = a in
let (b0,b1,b2,b3,b4) = b in
let r = u64 0x1000003D10 in
let d0 = mul64_wide a0 b3
+. mul64_wide a1 b2
+. mul64_wide a2 b1
+. mul64_wide a3 b0 in
lemma_four_mul64_wide a0 a1 a2 a3 b0 b1 b2 b3;
assert (v d0 = v a0 * v b3 + v a1 * v b2 + v a2 * v b1 + v a3 * v b0);
assert (v d0 <= 16384 * (max52 * max52));
let c0 = mul64_wide a4 b4 in
lemma_bound_mul64_wide 64 64 max48 max48 a4 b4;
assert (v c0 = v a4 * v b4);
assert (v c0 <= 4096 * (max48 * max48));
let d1 = d0 +. mul64_wide r (to_u64 c0) in let c1 = to_u64 (c0 >>. 64ul) in
lemma_bound_add_mul64_wide_r 16384 d0 c0;
assert (v d1 = v d0 + v r * (v c0 % pow2 64));
assert (v d1 <= 16385 * (max52 * max52));
lemma_bound_rsh64_to c0;
assert (v c1 = v c0 / pow2 64);
lemma_bound_c0 c0;
assert (v c1 <= pow2 44);
let t3 = to_u64 d1 &. mask52 in let d2 = d1 >>. 52ul in
lemma_bound_mask52_rsh52 16385 d1;
assert (v t3 = v d1 % pow2 52);
assert (felem_fits1 t3 1);
assert (v d2 = v d1 / pow2 52);
assert (v d2 <= 16385 * max52);
let d3 = d2
+. mul64_wide a0 b4
+. mul64_wide a1 b3
+. mul64_wide a2 b2
+. mul64_wide a3 b1
+. mul64_wide a4 b0 in
lemma_add_five_mul64_wide 16385 d2 a0 a1 a2 a3 a4 b0 b1 b2 b3 b4;
assert (v d3 == v d2 + v a0 * v b4 + v a1 * v b3 + v a2 * v b2 + v a3 * v b1 + v a4 * v b0);
assert (v d3 <= 12801 * (max52 * max52));
let d4 = d3 +. mul64_wide (r <<. 12ul) c1 in
lemma_bound_add_mul64_wide_r_lsh12 12801 d3 c1;
assert (v d4 == v d3 + v r * pow2 12 * v c1);
assert (v d4 <= 12802 * (max52 * max52));
let t4 = to_u64 d4 &. mask52 in let d5 = d4 >>. 52ul in
lemma_bound_mask52_rsh52 12802 d4;
assert (v t4 = v d4 % pow2 52);
assert (felem_fits1 t4 1);
assert (v d5 = v d4 / pow2 52);
assert (v d5 <= 12802 * max52);
let tx = t4 >>. 48ul in let t4' = t4 &. mask48 in
lemma_bound_mask48_rsh48 t4;
assert (v tx = v t4 / pow2 48);
assert (v tx < pow2 4);
assert (v t4' = v t4 % pow2 48);
assert (felem_fits_last1 t4' 1);
let c2 = mul64_wide a0 b0 in
lemma_bound_mul64_wide 64 64 max52 max52 a0 b0;
assert (v c2 = v a0 * v b0);
assert (v c2 <= 4096 * (max52 * max52));
let d6 = d5
+. mul64_wide a1 b4
+. mul64_wide a2 b3
+. mul64_wide a3 b2
+. mul64_wide a4 b1 in
lemma_add_four_mul64_wide 12802 d5 a1 a2 a3 a4 b1 b2 b3 b4;
assert (v d6 == v d5 + v a1 * v b4 + v a2 * v b3 + v a3 * v b2 + v a4 * v b1);
assert (v d6 <= 8705 * (max52 * max52));
let u0 = to_u64 d6 &. mask52 in let d7 = d6 >>. 52ul in
lemma_bound_mask52_rsh52 8705 d6;
assert (v u0 = v d6 % pow2 52);
assert (felem_fits1 u0 1);
assert (v d7 = v d6 / pow2 52);
assert (v d7 <= 8705 * max52);
let u0' = tx |. (u0 <<. 4ul) in
lemma_tx_logor_u0_lsh4 tx u0;
assert (v u0' == v tx + v u0 * pow2 4);
assert (v u0' < pow2 56);
let c3 = c2 +. mul64_wide u0' (r >>. 4ul) in
lemma_bound_add_mul64_wide_r_rsh4 4096 c2 u0';
assert (v c3 = v c2 + v u0' * (v r / pow2 4));
assert (v c3 <= 4097 * (max52 * max52));
let r0 = to_u64 c3 &. mask52 in let c4 = c3 >>. 52ul in
lemma_bound_mask52_rsh52 4097 c3;
assert (v r0 = v c3 % pow2 52);
assert (felem_fits1 r0 1);
assert (v c4 = v c3 / pow2 52);
assert (v c4 <= 4097 * max52);
let c5 = c4
+. mul64_wide a0 b1
+. mul64_wide a1 b0 in
lemma_add_two_mul64_wide52 4097 c4 a0 a1 b0 b1;
assert (v c5 = v c4 + v a0 * v b1 + v a1 * v b0);
assert (v c5 <= 8193 * (max52 * max52));
let d8 = d7
+. mul64_wide a2 b4
+. mul64_wide a3 b3
+. mul64_wide a4 b2 in
lemma_add_three_mul64_wide 8705 d7 a2 a3 a4 b2 b3 b4;
assert (v d8 = v d7 + v a2 * v b4 + v a3 * v b3 + v a4 * v b2);
assert (v d8 <= 4609 * (max52 * max52));
let c6 = c5 +. mul64_wide (to_u64 d8 &. mask52) r in let d9 = d8 >>. 52ul in
lemma_bound_add_mul64_wide_r_mask52 8193 d8 c5;
assert (v d9 = v d8 / pow2 52);
assert (v d9 <= 8193 * max52);
assert (v c6 = v c5 + v d8 % pow2 52 * v r);
assert (v c6 <= 8194 * (max52 * max52));
let r1 = to_u64 c6 &. mask52 in let c7 = c6 >>. 52ul in
lemma_bound_mask52_rsh52 8194 c6;
assert (v r1 = v c6 % pow2 52);
assert (felem_fits1 r1 1);
assert (v c7 = v c6 / pow2 52);
assert (v c7 <= 8194 * max52);
let c8 = c7
+. mul64_wide a0 b2
+. mul64_wide a1 b1
+. mul64_wide a2 b0 in
lemma_add_three_mul64_wide52 8194 c7 a0 a1 a2 b0 b1 b2;
assert (v c8 == v c7 + v a0 * v b2 + v a1 * v b1 + v a2 * v b0);
assert (v c8 <= 12289 * (max52 * max52));
let d10 = d9
+. mul64_wide a3 b4
+. mul64_wide a4 b3 in
lemma_add_two_mul64_wide 8193 d9 a3 a4 b3 b4;
assert (v d10 == v d9 + v a3 * v b4 + v a4 * v b3);
assert (v d10 <= 513 * (max52 * max52));
let c9 = c8 +. mul64_wide r (to_u64 d10) in let d11 = to_u64 (d10 >>. 64ul) in
lemma_bound_add_mul64_wide_r 12289 c8 d10;
assert (v c9 = v c8 + v r * (v d10 % pow2 64));
assert (v c9 <= 12290 * (max52 * max52));
lemma_bound_rsh64_to d10;
assert (v d11 = v d10 / pow2 64);
lemma_bound_d10 d10;
assert (v d11 < pow2 50);
let r2 = to_u64 c9 &. mask52 in let c10 = c9 >>. 52ul in
lemma_bound_mask52_rsh52 12290 c9;
assert (v r2 = v c9 % pow2 52);
assert (felem_fits1 r2 1);
assert (v c10 = v c9 / pow2 52);
assert (v c10 <= 12290 * max52);
let c11 = c10 +. mul64_wide (r <<. 12ul) d11 +. to_u128 t3 in
lemma_bound_add_mul64_wide_r_lsh12_add 12290 c10 d11 t3;
assert (v c11 = v c10 + v r * pow2 12 * v d11 + v t3);
assert (v c11 < pow2 100);
let r3 = to_u64 c11 &. mask52 in let c12 = to_u64 (c11 >>. 52ul) in
lemma_bound_mask52_rsh52_sp c11;
assert (v r3 = v c11 % pow2 52);
assert (felem_fits1 r3 1);
assert (v c12 = v c11 / pow2 52);
assert (v c12 < pow2 48);
let r4 = c12 +. t4' in
lemma_mod_add_last c12 t4';
assert (v r4 = v c12 + v t4');
assert (felem_fits_last1 r4 2);
let res = (r0,r1,r2,r3,r4) in
assert (res == fmul5 a b);
assert (felem_fits5 res (1,1,1,1,2));
L4.lemma_fmul_simplify (v r0) (v r1) (v r2) (v r3) (v r4)
(v c3) (v c6) (v c9) (v c11) (v d4) (v d8) (v d10) (v d11)
(v t3) (v a0) (v a1) (v a2) (v a3) (v a4) (v b0) (v b1) (v b2) (v b3) (v b4)
/// squaring
val fsqr5_lemma: a:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64))
(ensures (let res = fsqr5 a in
as_nat5 res % S.prime == as_nat5 a * as_nat5 a % S.prime /\
felem_fits5 res (1,1,1,1,2))) | false | false | Hacl.Spec.K256.Field52.Lemmas3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 150,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fsqr5_lemma: a:felem5 -> Lemma
(requires
felem_fits5 a (64,64,64,64,64))
(ensures (let res = fsqr5 a in
as_nat5 res % S.prime == as_nat5 a * as_nat5 a % S.prime /\
felem_fits5 res (1,1,1,1,2))) | [] | Hacl.Spec.K256.Field52.Lemmas3.fsqr5_lemma | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Lemmas3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.K256.Field52.Definitions.felem5
-> FStar.Pervasives.Lemma
(requires Hacl.Spec.K256.Field52.Definitions.felem_fits5 a (64, 64, 64, 64, 64))
(ensures
(let res = Hacl.Spec.K256.Field52.fsqr5 a in
Hacl.Spec.K256.Field52.Definitions.as_nat5 res % Spec.K256.PointOps.prime ==
Hacl.Spec.K256.Field52.Definitions.as_nat5 a *
Hacl.Spec.K256.Field52.Definitions.as_nat5 a %
Spec.K256.PointOps.prime /\
Hacl.Spec.K256.Field52.Definitions.felem_fits5 res (1, 1, 1, 1, 2))) | {
"end_col": 80,
"end_line": 392,
"start_col": 19,
"start_line": 220
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lbignum (t:limb_t) len = lbuffer (limb t) len | let lbignum (t: limb_t) len = | false | null | false | lbuffer (limb t) len | {
"checked_file": "Hacl.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Definitions.fst"
} | [
"total"
] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Hacl.Bignum.Definitions.limb"
] | [] | module Hacl.Bignum.Definitions
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module S = Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val blocks: x:size_t{v x > 0} -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks (v x) (v m)}
let blocks x m = (x -. 1ul) /. m +. 1ul
inline_for_extraction noextract
val blocks0: x:size_t -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks0 (v x) (v m)}
let blocks0 x m = if x =. 0ul then 1ul else (x -. 1ul) /. m +. 1ul
inline_for_extraction noextract
let limb_t = S.limb_t
inline_for_extraction noextract
let limb (t:limb_t) = S.limb t | false | true | Hacl.Bignum.Definitions.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lbignum : t: Hacl.Bignum.Definitions.limb_t -> len: Lib.IntTypes.size_t -> Type0 | [] | Hacl.Bignum.Definitions.lbignum | {
"file_name": "code/bignum/Hacl.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t: Hacl.Bignum.Definitions.limb_t -> len: Lib.IntTypes.size_t -> Type0 | {
"end_col": 49,
"end_line": 29,
"start_col": 29,
"start_line": 29
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let limb_t = S.limb_t | let limb_t = | false | null | false | S.limb_t | {
"checked_file": "Hacl.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Definitions.fst"
} | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t"
] | [] | module Hacl.Bignum.Definitions
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module S = Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val blocks: x:size_t{v x > 0} -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks (v x) (v m)}
let blocks x m = (x -. 1ul) /. m +. 1ul
inline_for_extraction noextract
val blocks0: x:size_t -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks0 (v x) (v m)}
let blocks0 x m = if x =. 0ul then 1ul else (x -. 1ul) /. m +. 1ul | false | true | Hacl.Bignum.Definitions.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val limb_t : Type0 | [] | Hacl.Bignum.Definitions.limb_t | {
"file_name": "code/bignum/Hacl.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 21,
"end_line": 23,
"start_col": 13,
"start_line": 23
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let limb (t:limb_t) = S.limb t | let limb (t: limb_t) = | false | null | false | S.limb t | {
"checked_file": "Hacl.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Definitions.fst"
} | [
"total"
] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.Definitions.limb"
] | [] | module Hacl.Bignum.Definitions
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module S = Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val blocks: x:size_t{v x > 0} -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks (v x) (v m)}
let blocks x m = (x -. 1ul) /. m +. 1ul
inline_for_extraction noextract
val blocks0: x:size_t -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks0 (v x) (v m)}
let blocks0 x m = if x =. 0ul then 1ul else (x -. 1ul) /. m +. 1ul
inline_for_extraction noextract
let limb_t = S.limb_t | false | true | Hacl.Bignum.Definitions.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val limb : t: Hacl.Bignum.Definitions.limb_t -> Type0 | [] | Hacl.Bignum.Definitions.limb | {
"file_name": "code/bignum/Hacl.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | t: Hacl.Bignum.Definitions.limb_t -> Type0 | {
"end_col": 30,
"end_line": 26,
"start_col": 22,
"start_line": 26
} |
|
Prims.GTot | val bn_v: #t:limb_t -> #len:size_t -> h:mem -> b:lbignum t len -> GTot nat | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bn_v #t #len h b = S.bn_v #t #(v len) (as_seq h b) | val bn_v: #t:limb_t -> #len:size_t -> h:mem -> b:lbignum t len -> GTot nat
let bn_v #t #len h b = | false | null | false | S.bn_v #t #(v len) (as_seq h b) | {
"checked_file": "Hacl.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Definitions.fst"
} | [
"sometrivial"
] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"FStar.Monotonic.HyperStack.mem",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Hacl.Bignum.Definitions.limb",
"Prims.nat"
] | [] | module Hacl.Bignum.Definitions
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module S = Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val blocks: x:size_t{v x > 0} -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks (v x) (v m)}
let blocks x m = (x -. 1ul) /. m +. 1ul
inline_for_extraction noextract
val blocks0: x:size_t -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks0 (v x) (v m)}
let blocks0 x m = if x =. 0ul then 1ul else (x -. 1ul) /. m +. 1ul
inline_for_extraction noextract
let limb_t = S.limb_t
inline_for_extraction noextract
let limb (t:limb_t) = S.limb t
inline_for_extraction noextract
let lbignum (t:limb_t) len = lbuffer (limb t) len
noextract | false | false | Hacl.Bignum.Definitions.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bn_v: #t:limb_t -> #len:size_t -> h:mem -> b:lbignum t len -> GTot nat | [] | Hacl.Bignum.Definitions.bn_v | {
"file_name": "code/bignum/Hacl.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | h: FStar.Monotonic.HyperStack.mem -> b: Hacl.Bignum.Definitions.lbignum t len
-> Prims.GTot Prims.nat | {
"end_col": 54,
"end_line": 33,
"start_col": 23,
"start_line": 33
} |
Prims.Tot | val blocks: x:size_t{v x > 0} -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks (v x) (v m)} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let blocks x m = (x -. 1ul) /. m +. 1ul | val blocks: x:size_t{v x > 0} -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks (v x) (v m)}
let blocks x m = | false | null | false | (x -. 1ul) /. m +. 1ul | {
"checked_file": "Hacl.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Definitions.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_GreaterThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.op_Slash_Dot",
"Lib.IntTypes.op_Subtraction_Dot",
"FStar.UInt32.__uint_to_t",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks"
] | [] | module Hacl.Bignum.Definitions
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module S = Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract | false | false | Hacl.Bignum.Definitions.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val blocks: x:size_t{v x > 0} -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks (v x) (v m)} | [] | Hacl.Bignum.Definitions.blocks | {
"file_name": "code/bignum/Hacl.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntTypes.size_t{Lib.IntTypes.v x > 0} -> m: Lib.IntTypes.size_t{Lib.IntTypes.v m > 0}
-> r:
Lib.IntTypes.size_t
{ Lib.IntTypes.v r ==
Hacl.Spec.Bignum.Definitions.blocks (Lib.IntTypes.v x) (Lib.IntTypes.v m) } | {
"end_col": 39,
"end_line": 16,
"start_col": 17,
"start_line": 16
} |
Prims.Tot | val blocks0: x:size_t -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks0 (v x) (v m)} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let blocks0 x m = if x =. 0ul then 1ul else (x -. 1ul) /. m +. 1ul | val blocks0: x:size_t -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks0 (v x) (v m)}
let blocks0 x m = | false | null | false | if x =. 0ul then 1ul else (x -. 1ul) /. m +. 1ul | {
"checked_file": "Hacl.Bignum.Definitions.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Bignum.Definitions.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_GreaterThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.op_Equals_Dot",
"FStar.UInt32.__uint_to_t",
"Prims.bool",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.op_Slash_Dot",
"Lib.IntTypes.op_Subtraction_Dot",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.blocks0"
] | [] | module Hacl.Bignum.Definitions
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module S = Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val blocks: x:size_t{v x > 0} -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks (v x) (v m)}
let blocks x m = (x -. 1ul) /. m +. 1ul
inline_for_extraction noextract | false | false | Hacl.Bignum.Definitions.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val blocks0: x:size_t -> m:size_t{v m > 0} -> r:size_t{v r == S.blocks0 (v x) (v m)} | [] | Hacl.Bignum.Definitions.blocks0 | {
"file_name": "code/bignum/Hacl.Bignum.Definitions.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntTypes.size_t -> m: Lib.IntTypes.size_t{Lib.IntTypes.v m > 0}
-> r:
Lib.IntTypes.size_t
{ Lib.IntTypes.v r ==
Hacl.Spec.Bignum.Definitions.blocks0 (Lib.IntTypes.v x) (Lib.IntTypes.v m) } | {
"end_col": 66,
"end_line": 20,
"start_col": 18,
"start_line": 20
} |
Prims.Tot | val v (x:t) : Tot (uint_t n) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let v x = x.v | val v (x:t) : Tot (uint_t n)
let v x = | false | null | false | x.v | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [
"total"
] | [
"FStar.UInt32.t",
"FStar.UInt32.__proj__Mk__item__v",
"FStar.UInt.uint_t",
"FStar.UInt32.n"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t | false | true | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val v (x:t) : Tot (uint_t n) | [] | FStar.UInt32.v | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: FStar.UInt32.t -> FStar.UInt.uint_t FStar.UInt32.n | {
"end_col": 13,
"end_line": 28,
"start_col": 10,
"start_line": 28
} |
Prims.Tot | val zero : x:t{v x = 0} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let zero = uint_to_t 0 | val zero : x:t{v x = 0}
let zero = | false | null | false | uint_to_t 0 | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [
"total"
] | [
"FStar.UInt32.uint_to_t"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = () | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val zero : x:t{v x = 0} | [] | FStar.UInt32.zero | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: FStar.UInt32.t{FStar.UInt32.v x = 0} | {
"end_col": 22,
"end_line": 38,
"start_col": 11,
"start_line": 38
} |
Prims.Pure | val mul_underspec (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c ->
size (v a * v b) n ==> v a * v b = v c)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mul_underspec a b = Mk (mul_underspec (v a) (v b)) | val mul_underspec (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c ->
size (v a * v b) n ==> v a * v b = v c))
let mul_underspec a b = | false | null | false | Mk (mul_underspec (v a) (v b)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.mul_underspec",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b))
let add_mod a b = Mk (add_mod (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let sub_underspec a b = Mk (sub_underspec (v a) (v b))
let sub_mod a b = Mk (sub_mod (v a) (v b))
let mul a b = Mk (mul (v a) (v b)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mul_underspec (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c ->
size (v a * v b) n ==> v a * v b = v c)) | [] | FStar.UInt32.mul_underspec | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt32.t -> b: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 54,
"end_line": 56,
"start_col": 24,
"start_line": 56
} |
Prims.Tot | val one : x:t{v x = 1} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let one = uint_to_t 1 | val one : x:t{v x = 1}
let one = | false | null | false | uint_to_t 1 | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [
"total"
] | [
"FStar.UInt32.uint_to_t"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0 | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val one : x:t{v x = 1} | [] | FStar.UInt32.one | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: FStar.UInt32.t{FStar.UInt32.v x = 1} | {
"end_col": 21,
"end_line": 40,
"start_col": 10,
"start_line": 40
} |
Prims.Pure | val sub_underspec (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c ->
size (v a - v b) n ==> v a - v b = v c)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let sub_underspec a b = Mk (sub_underspec (v a) (v b)) | val sub_underspec (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c ->
size (v a - v b) n ==> v a - v b = v c))
let sub_underspec a b = | false | null | false | Mk (sub_underspec (v a) (v b)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.sub_underspec",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b))
let add_mod a b = Mk (add_mod (v a) (v b))
let sub a b = Mk (sub (v a) (v b)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sub_underspec (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c ->
size (v a - v b) n ==> v a - v b = v c)) | [] | FStar.UInt32.sub_underspec | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt32.t -> b: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 54,
"end_line": 50,
"start_col": 24,
"start_line": 50
} |
Prims.Pure | val add_underspec (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c ->
size (v a + v b) n ==> v a + v b = v c)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let add_underspec a b = Mk (add_underspec (v a) (v b)) | val add_underspec (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c ->
size (v a + v b) n ==> v a + v b = v c))
let add_underspec a b = | false | null | false | Mk (add_underspec (v a) (v b)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.add_underspec",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val add_underspec (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c ->
size (v a + v b) n ==> v a + v b = v c)) | [] | FStar.UInt32.add_underspec | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt32.t -> b: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 54,
"end_line": 44,
"start_col": 24,
"start_line": 44
} |
Prims.Pure | val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let logor x y = Mk (logor (v x) (v y)) | val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
let logor x y = | false | null | false | Mk (logor (v x) (v y)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.logor",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b))
let add_mod a b = Mk (add_mod (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let sub_underspec a b = Mk (sub_underspec (v a) (v b))
let sub_mod a b = Mk (sub_mod (v a) (v b))
let mul a b = Mk (mul (v a) (v b))
let mul_underspec a b = Mk (mul_underspec (v a) (v b))
let mul_mod a b = Mk (mul_mod (v a) (v b))
let div a b = Mk (div (v a) (v b))
let rem a b = Mk (mod (v a) (v b))
let logand x y = Mk (logand (v x) (v y))
let logxor x y = Mk (logxor (v x) (v y)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z)) | [] | FStar.UInt32.logor | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: FStar.UInt32.t -> y: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 38,
"end_line": 68,
"start_col": 16,
"start_line": 68
} |
Prims.Pure | val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let sub a b = Mk (sub (v a) (v b)) | val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
let sub a b = | false | null | false | Mk (sub (v a) (v b)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.sub",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b))
let add_mod a b = Mk (add_mod (v a) (v b)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c)) | [] | FStar.UInt32.sub | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt32.t -> b: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 34,
"end_line": 48,
"start_col": 14,
"start_line": 48
} |
Prims.Pure | val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let add a b = Mk (add (v a) (v b)) | val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
let add a b = | false | null | false | Mk (add (v a) (v b)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.add",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1 | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c)) | [] | FStar.UInt32.add | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt32.t -> b: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 34,
"end_line": 42,
"start_col": 14,
"start_line": 42
} |
Prims.Pure | val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let logxor x y = Mk (logxor (v x) (v y)) | val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
let logxor x y = | false | null | false | Mk (logxor (v x) (v y)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.logxor",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b))
let add_mod a b = Mk (add_mod (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let sub_underspec a b = Mk (sub_underspec (v a) (v b))
let sub_mod a b = Mk (sub_mod (v a) (v b))
let mul a b = Mk (mul (v a) (v b))
let mul_underspec a b = Mk (mul_underspec (v a) (v b))
let mul_mod a b = Mk (mul_mod (v a) (v b))
let div a b = Mk (div (v a) (v b))
let rem a b = Mk (mod (v a) (v b))
let logand x y = Mk (logand (v x) (v y)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z)) | [] | FStar.UInt32.logxor | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: FStar.UInt32.t -> y: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 40,
"end_line": 66,
"start_col": 17,
"start_line": 66
} |
Prims.Pure | val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mul a b = Mk (mul (v a) (v b)) | val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
let mul a b = | false | null | false | Mk (mul (v a) (v b)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.mul",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b))
let add_mod a b = Mk (add_mod (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let sub_underspec a b = Mk (sub_underspec (v a) (v b))
let sub_mod a b = Mk (sub_mod (v a) (v b)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c)) | [] | FStar.UInt32.mul | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt32.t -> b: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 34,
"end_line": 54,
"start_col": 14,
"start_line": 54
} |
Prims.Pure | val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lognot x = Mk (lognot (v x)) | val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
let lognot x = | false | null | false | Mk (lognot (v x)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.lognot",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b))
let add_mod a b = Mk (add_mod (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let sub_underspec a b = Mk (sub_underspec (v a) (v b))
let sub_mod a b = Mk (sub_mod (v a) (v b))
let mul a b = Mk (mul (v a) (v b))
let mul_underspec a b = Mk (mul_underspec (v a) (v b))
let mul_mod a b = Mk (mul_mod (v a) (v b))
let div a b = Mk (div (v a) (v b))
let rem a b = Mk (mod (v a) (v b))
let logand x y = Mk (logand (v x) (v y))
let logxor x y = Mk (logxor (v x) (v y))
let logor x y = Mk (logor (v x) (v y)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z)) | [] | FStar.UInt32.lognot | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 32,
"end_line": 70,
"start_col": 15,
"start_line": 70
} |
Prims.Pure | val add_mod (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c -> FStar.UInt.add_mod (v a) (v b) = v c)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let add_mod a b = Mk (add_mod (v a) (v b)) | val add_mod (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c -> FStar.UInt.add_mod (v a) (v b) = v c))
let add_mod a b = | false | null | false | Mk (add_mod (v a) (v b)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.add_mod",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val add_mod (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c -> FStar.UInt.add_mod (v a) (v b) = v c)) | [] | FStar.UInt32.add_mod | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt32.t -> b: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 42,
"end_line": 46,
"start_col": 18,
"start_line": 46
} |
Prims.Pure | val uint_to_t (x:uint_t n) : Pure t
(requires True)
(ensures (fun y -> v y = x)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let uint_to_t x = Mk x | val uint_to_t (x:uint_t n) : Pure t
(requires True)
(ensures (fun y -> v y = x))
let uint_to_t x = | false | null | false | Mk x | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt.uint_t",
"FStar.UInt32.n",
"FStar.UInt32.Mk",
"FStar.UInt32.t"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val uint_to_t (x:uint_t n) : Pure t
(requires True)
(ensures (fun y -> v y = x)) | [] | FStar.UInt32.uint_to_t | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: FStar.UInt.uint_t FStar.UInt32.n -> Prims.Pure FStar.UInt32.t | {
"end_col": 22,
"end_line": 30,
"start_col": 18,
"start_line": 30
} |
Prims.Pure | val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires True)
(ensures (fun c -> FStar.UInt.mod (v a) (v b) = v c)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rem a b = Mk (mod (v a) (v b)) | val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires True)
(ensures (fun c -> FStar.UInt.mod (v a) (v b) = v c))
let rem a b = | false | null | false | Mk (mod (v a) (v b)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_disEquality",
"Prims.int",
"FStar.UInt32.v",
"FStar.UInt32.Mk",
"FStar.UInt.mod",
"FStar.UInt32.n"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b))
let add_mod a b = Mk (add_mod (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let sub_underspec a b = Mk (sub_underspec (v a) (v b))
let sub_mod a b = Mk (sub_mod (v a) (v b))
let mul a b = Mk (mul (v a) (v b))
let mul_underspec a b = Mk (mul_underspec (v a) (v b))
let mul_mod a b = Mk (mul_mod (v a) (v b))
let div a b = Mk (div (v a) (v b)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires True)
(ensures (fun c -> FStar.UInt.mod (v a) (v b) = v c)) | [] | FStar.UInt32.rem | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt32.t -> b: FStar.UInt32.t{FStar.UInt32.v b <> 0} -> Prims.Pure FStar.UInt32.t | {
"end_col": 34,
"end_line": 62,
"start_col": 14,
"start_line": 62
} |
Prims.Pure | val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let logand x y = Mk (logand (v x) (v y)) | val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
let logand x y = | false | null | false | Mk (logand (v x) (v y)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.logand",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b))
let add_mod a b = Mk (add_mod (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let sub_underspec a b = Mk (sub_underspec (v a) (v b))
let sub_mod a b = Mk (sub_mod (v a) (v b))
let mul a b = Mk (mul (v a) (v b))
let mul_underspec a b = Mk (mul_underspec (v a) (v b))
let mul_mod a b = Mk (mul_mod (v a) (v b))
let div a b = Mk (div (v a) (v b))
let rem a b = Mk (mod (v a) (v b)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z)) | [] | FStar.UInt32.logand | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: FStar.UInt32.t -> y: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 40,
"end_line": 64,
"start_col": 17,
"start_line": 64
} |
Prims.Pure | val sub_mod (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c -> FStar.UInt.sub_mod (v a) (v b) = v c)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let sub_mod a b = Mk (sub_mod (v a) (v b)) | val sub_mod (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c -> FStar.UInt.sub_mod (v a) (v b) = v c))
let sub_mod a b = | false | null | false | Mk (sub_mod (v a) (v b)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.sub_mod",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b))
let add_mod a b = Mk (add_mod (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let sub_underspec a b = Mk (sub_underspec (v a) (v b)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sub_mod (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c -> FStar.UInt.sub_mod (v a) (v b) = v c)) | [] | FStar.UInt32.sub_mod | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt32.t -> b: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 42,
"end_line": 52,
"start_col": 18,
"start_line": 52
} |
Prims.Pure | val mul_mod (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c -> FStar.UInt.mul_mod (v a) (v b) = v c)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mul_mod a b = Mk (mul_mod (v a) (v b)) | val mul_mod (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c -> FStar.UInt.mul_mod (v a) (v b) = v c))
let mul_mod a b = | false | null | false | Mk (mul_mod (v a) (v b)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.mul_mod",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b))
let add_mod a b = Mk (add_mod (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let sub_underspec a b = Mk (sub_underspec (v a) (v b))
let sub_mod a b = Mk (sub_mod (v a) (v b))
let mul a b = Mk (mul (v a) (v b))
let mul_underspec a b = Mk (mul_underspec (v a) (v b)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mul_mod (a:t) (b:t) : Pure t
(requires True)
(ensures (fun c -> FStar.UInt.mul_mod (v a) (v b) = v c)) | [] | FStar.UInt32.mul_mod | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt32.t -> b: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 42,
"end_line": 58,
"start_col": 18,
"start_line": 58
} |
Prims.Pure | val shift_left (a:t) (s:t) : Pure t
(requires (v s < n))
(ensures (fun c -> FStar.UInt.shift_left (v a) (v s) = v c)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let shift_left a s = Mk (shift_left (v a) (v s)) | val shift_left (a:t) (s:t) : Pure t
(requires (v s < n))
(ensures (fun c -> FStar.UInt.shift_left (v a) (v s) = v c))
let shift_left a s = | false | null | false | Mk (shift_left (v a) (v s)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.shift_left",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b))
let add_mod a b = Mk (add_mod (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let sub_underspec a b = Mk (sub_underspec (v a) (v b))
let sub_mod a b = Mk (sub_mod (v a) (v b))
let mul a b = Mk (mul (v a) (v b))
let mul_underspec a b = Mk (mul_underspec (v a) (v b))
let mul_mod a b = Mk (mul_mod (v a) (v b))
let div a b = Mk (div (v a) (v b))
let rem a b = Mk (mod (v a) (v b))
let logand x y = Mk (logand (v x) (v y))
let logxor x y = Mk (logxor (v x) (v y))
let logor x y = Mk (logor (v x) (v y))
let lognot x = Mk (lognot (v x))
let shift_right a s = Mk (shift_right (v a) (v s))
#push-options "--z3rlimit 80 --fuel 1" //AR: working around the interleaving semantics of pragmas | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 80,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val shift_left (a:t) (s:t) : Pure t
(requires (v s < n))
(ensures (fun c -> FStar.UInt.shift_left (v a) (v s) = v c)) | [] | FStar.UInt32.shift_left | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt32.t -> s: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 48,
"end_line": 76,
"start_col": 21,
"start_line": 76
} |
Prims.Pure | val shift_right (a:t) (s:t) : Pure t
(requires (v s < n))
(ensures (fun c -> FStar.UInt.shift_right (v a) (v s) = v c)) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let shift_right a s = Mk (shift_right (v a) (v s)) | val shift_right (a:t) (s:t) : Pure t
(requires (v s < n))
(ensures (fun c -> FStar.UInt.shift_right (v a) (v s) = v c))
let shift_right a s = | false | null | false | Mk (shift_right (v a) (v s)) | {
"checked_file": "FStar.UInt32.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "FStar.UInt32.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.UInt32.Mk",
"FStar.UInt.shift_right",
"FStar.UInt32.n",
"FStar.UInt32.v"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.UInt32
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.UInt
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
type t : eqtype =
| Mk: v:uint_t n -> t
let v x = x.v
let uint_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = uint_to_t 0
let one = uint_to_t 1
let add a b = Mk (add (v a) (v b))
let add_underspec a b = Mk (add_underspec (v a) (v b))
let add_mod a b = Mk (add_mod (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let sub_underspec a b = Mk (sub_underspec (v a) (v b))
let sub_mod a b = Mk (sub_mod (v a) (v b))
let mul a b = Mk (mul (v a) (v b))
let mul_underspec a b = Mk (mul_underspec (v a) (v b))
let mul_mod a b = Mk (mul_mod (v a) (v b))
let div a b = Mk (div (v a) (v b))
let rem a b = Mk (mod (v a) (v b))
let logand x y = Mk (logand (v x) (v y))
let logxor x y = Mk (logxor (v x) (v y))
let logor x y = Mk (logor (v x) (v y))
let lognot x = Mk (lognot (v x)) | false | false | FStar.UInt32.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val shift_right (a:t) (s:t) : Pure t
(requires (v s < n))
(ensures (fun c -> FStar.UInt.shift_right (v a) (v s) = v c)) | [] | FStar.UInt32.shift_right | {
"file_name": "ulib/FStar.UInt32.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.UInt32.t -> s: FStar.UInt32.t -> Prims.Pure FStar.UInt32.t | {
"end_col": 50,
"end_line": 72,
"start_col": 22,
"start_line": 72
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.