file_name
stringlengths 5
52
| name
stringlengths 4
95
| original_source_type
stringlengths 0
23k
| source_type
stringlengths 9
23k
| source_definition
stringlengths 9
57.9k
| source
dict | source_range
dict | file_context
stringlengths 0
721k
| dependencies
dict | opens_and_abbrevs
listlengths 2
94
| vconfig
dict | interleaved
bool 1
class | verbose_type
stringlengths 1
7.42k
| effect
stringclasses 118
values | effect_flags
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 0
1
| is_simple_lemma
bool 2
classes | is_div
bool 2
classes | is_proof
bool 2
classes | is_simply_typed
bool 2
classes | is_type
bool 2
classes | partial_definition
stringlengths 5
3.99k
| completed_definiton
stringlengths 1
1.63M
| isa_cross_project_example
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.Int128.fst | FStar.Int128.shift_left | val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) | val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c)) | let shift_left a s = Mk (shift_left (v a) (UInt32.v s)) | {
"file_name": "ulib/FStar.Int128.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 55,
"end_line": 69,
"start_col": 0,
"start_line": 69
} | (*
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.Int128
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
type t : eqtype =
| Mk: v:int_t n -> t
let v x = x.v
irreducible
let int_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = int_to_t 0
let one =
FStar.Math.Lemmas.pow2_lt_compat (n - 1) 1;
int_to_t 1
let add a b = Mk (add (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let mul a b = Mk (mul (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) (UInt32.v s)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Int64.fsti.checked",
"FStar.Int.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Int128.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"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
}
] | {
"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"
} | false | a: FStar.Int128.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int128.t | Prims.Pure | [] | [] | [
"FStar.Int128.t",
"FStar.UInt32.t",
"FStar.Int128.Mk",
"FStar.Int.shift_left",
"FStar.Int128.n",
"FStar.Int128.v",
"FStar.UInt32.v"
] | [] | false | false | false | false | false | let shift_left a s =
| Mk (shift_left (v a) (UInt32.v s)) | false |
FStar.Int128.fst | FStar.Int128.mul | val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c)) | 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 = Mk (mul (v a) (v b)) | {
"file_name": "ulib/FStar.Int128.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 53,
"start_col": 0,
"start_line": 53
} | (*
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.Int128
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
type t : eqtype =
| Mk: v:int_t n -> t
let v x = x.v
irreducible
let int_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = int_to_t 0
let one =
FStar.Math.Lemmas.pow2_lt_compat (n - 1) 1;
int_to_t 1
let add a b = Mk (add (v a) (v b))
let sub a b = Mk (sub (v a) (v b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Int64.fsti.checked",
"FStar.Int.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Int128.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"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
}
] | {
"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"
} | false | a: FStar.Int128.t -> b: FStar.Int128.t -> Prims.Pure FStar.Int128.t | Prims.Pure | [] | [] | [
"FStar.Int128.t",
"FStar.Int128.Mk",
"FStar.Int.mul",
"FStar.Int128.n",
"FStar.Int128.v"
] | [] | false | false | false | false | false | let mul a b =
| Mk (mul (v a) (v b)) | false |
FStar.Int128.fst | FStar.Int128.div | val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c)) | val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c)) | let div a b = Mk (div (v a) (v b)) | {
"file_name": "ulib/FStar.Int128.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 55,
"start_col": 0,
"start_line": 55
} | (*
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.Int128
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
type t : eqtype =
| Mk: v:int_t n -> t
let v x = x.v
irreducible
let int_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = int_to_t 0
let one =
FStar.Math.Lemmas.pow2_lt_compat (n - 1) 1;
int_to_t 1
let add a b = Mk (add (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let mul a b = Mk (mul (v a) (v b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Int64.fsti.checked",
"FStar.Int.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Int128.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"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
}
] | {
"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"
} | false | a: FStar.Int128.t -> b: FStar.Int128.t{FStar.Int128.v b <> 0} -> Prims.Pure FStar.Int128.t | Prims.Pure | [] | [] | [
"FStar.Int128.t",
"Prims.b2t",
"Prims.op_disEquality",
"Prims.int",
"FStar.Int128.v",
"FStar.Int128.Mk",
"FStar.Int.div",
"FStar.Int128.n"
] | [] | false | false | false | false | false | let div a b =
| Mk (div (v a) (v b)) | false |
FStar.Int128.fst | FStar.Int128.shift_arithmetic_right | val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) | val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) | let shift_arithmetic_right a s = Mk (shift_arithmetic_right (v a) (UInt32.v s)) | {
"file_name": "ulib/FStar.Int128.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 79,
"end_line": 71,
"start_col": 0,
"start_line": 71
} | (*
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.Int128
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
type t : eqtype =
| Mk: v:int_t n -> t
let v x = x.v
irreducible
let int_to_t x = Mk x
let uv_inv _ = ()
let vu_inv _ = ()
let v_inj _ _ = ()
let zero = int_to_t 0
let one =
FStar.Math.Lemmas.pow2_lt_compat (n - 1) 1;
int_to_t 1
let add a b = Mk (add (v a) (v b))
let sub a b = Mk (sub (v a) (v b))
let mul a b = Mk (mul (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) (UInt32.v s))
let shift_left a s = Mk (shift_left (v a) (UInt32.v s)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Int64.fsti.checked",
"FStar.Int.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Int128.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"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
}
] | {
"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"
} | false | a: FStar.Int128.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int128.t | Prims.Pure | [] | [] | [
"FStar.Int128.t",
"FStar.UInt32.t",
"FStar.Int128.Mk",
"FStar.Int.shift_arithmetic_right",
"FStar.Int128.n",
"FStar.Int128.v",
"FStar.UInt32.v"
] | [] | false | false | false | false | false | let shift_arithmetic_right a s =
| Mk (shift_arithmetic_right (v a) (UInt32.v s)) | false |
IMST.fst | IMST.f | val f: Prims.unit -> IMST nat ((| nat, nat_rel |) >< (fun p s0 -> forall s1. s1 > s0 ==> p s0 s1)) | val f: Prims.unit -> IMST nat ((| nat, nat_rel |) >< (fun p s0 -> forall s1. s1 > s0 ==> p s0 s1)) | let f ()
: IMST nat ((|nat , nat_rel|) >< (fun p s0 -> forall s1 . s1 > s0 ==> p s0 s1))
= let s0 = get #nat #nat_rel () in
put #nat #nat_rel (s0 + 1);
let s1 = get #nat #nat_rel () in
assert (s1 > 0);
witness #nat #nat_rel (fun n -> n > 0);
put #nat #nat_rel (s1 * 42);
recall #nat #nat_rel (fun n -> n > 0);
let s2 = get #nat #nat_rel () in
assert (s2 > 0);
s0 | {
"file_name": "examples/indexed_effects/IMST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 6,
"end_line": 151,
"start_col": 0,
"start_line": 140
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 IMST
(* A proof-of-concept example of indexed effects (the state-and-preorder indexed MST effect) encoded using standard F* WP calculi *)
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(* The state-and-preorder indexed MST effect; defined explicitly rather than via DM4F due to the pi-types used in it *)
//s is at a fixed universe level (here #u0) because because otherwise sub_effect complains about being too universe polymorphic
let st_pre (s:Type0) = s -> GTot Type0
let st_post' (s:Type0) (a:Type) (pre:Type) = a -> (_:s{pre}) -> GTot Type0
let st_post (s:Type0) (a:Type) = st_post_h' s a True
let st_wp (a:Type) = s:Type0 -> (preorder s) -> st_post_h s a -> Tot (st_pre_h s)
unfold
let st_return (a:Type) (x:a) (s:Type0) (rel:preorder s) (post:st_post s a) (s0:s)
= forall v. v == x ==> post v s0
unfold
let st_bind (a:Type) (b:Type)
(wp1:st_wp a) (wp2: (a -> Tot (st_wp b)))
(s:Type0) (rel:preorder s) (post:st_post s b) (s0:s)
= wp1 s rel (fun x s1 -> wp2 x s rel post s1) s0
unfold
let st_if_then_else (a:Type) (p:Type)
(wp_then:st_wp a) (wp_else:st_wp a)
(s:Type0) (rel:preorder s) (post:st_post s a) (s0:s)
= l_ITE p (wp_then s rel post s0) (wp_else s rel post s0)
unfold
let st_ite (a:Type) (wp:st_wp a) (s:Type0) (rel:preorder s) (post:st_post s a) (s0:s)
= forall (k:st_post s a).
(forall (x:a) (s1:s).{:pattern (guard_free (k x s1))} post x s1 ==> k x s1)
==> wp s rel k s0
unfold
let st_stronger (a:Type) (wp1:st_wp a) (wp2:st_wp a)
= forall (s:Type0) (rel:preorder s) (p:st_post s a) (s0:s) . wp1 s rel p s0 ==> wp2 s rel p s0
unfold
let st_close (a:Type) (b:Type) (wp:(b -> GTot (st_wp a)))
(s:Type0) (rel:preorder s) (p:st_post s a) (s0:s)
= forall x. wp x s rel p s0
unfold
let st_trivial (a:Type) (wp:st_wp a)
= forall s rel s0. wp s rel (fun _ _ -> True) s0
new_effect {
IMST : result:Type -> wp:st_wp result -> Effect
with
//repr = s:Type0 -> preorder s -> s -> M (a * s) // - pi-types currently not supported by DM4F
//repr' = s:Type0 -> rel:preorder s -> s0:s -> M (a * s1:s{rel s0 s1})
// - pi-types currently not supported by DM4F;
// refinement types also currently not supported by DM4F
return_wp = st_return
; bind_wp = st_bind
; if_then_else = st_if_then_else
; ite_wp = st_ite
; stronger = st_stronger
; close_wp = st_close
; trivial = st_trivial
}
// For effects where subtyping parameters is sound, e.g.,
//
// exn:Type -> exns:set exn -> M (either a e:exn{mem e exns})
//
// there is also the problem of needing to subtype postconditions according to the chosen (subset) order on exns.
//
// The precise typing would (highly likely) be needed to ensure that reification/reflection are sound.
(* Standard lifting *)
unfold
let lift_div_imst (a:Type) (wp:pure_wp a) (s:Type0)
(rel:preorder s) (post:st_post s a) (s0:s)
= wp (fun x -> post x s0)
sub_effect DIV ~> IMST = lift_div_imst
(* Non-indexed MST WPs and syntactic sugar for writing effect indices *)
let st_wp' (a:Type) (s:Type0)
= st_post s a -> Tot (st_pre s)
unfold
let (><) (#a:Type) (sr:(s:Type0 & preorder s)) (wp:st_wp' a (dfst sr)) : st_wp a
= fun s rel post s0 -> s == dfst sr /\ (forall x y . rel x y <==> dsnd sr x y) /\ wp post s0
(* Standard, but now state-and-preorder indexed get, put, witness, and recall actions *)
assume val get (#s:Type0) (#rel:preorder s) (_:unit) : IMST s ((|s , rel|) >< (fun p s0 -> p s0 s0))
assume val put (#s:Type0) (#rel:preorder s) (s1:s) : IMST unit ((|s , rel|) >< (fun p s0 -> rel s0 s1 /\ p () s1))
let witnessed (#s:Type) (#rel:preorder s) (p:predicate s) :Type0 = W.witnessed rel p
assume val witness (#s:Type) (#rel:preorder s) (q:predicate s)
: IMST unit ((|s , rel|) >< (fun p s0 -> stable q rel /\ q s0 /\ (witnessed #s #rel q ==> p () s0)))
assume val recall (#s:Type) (#rel:preorder s) (q:predicate s)
: IMST unit ((|s , rel|) >< (fun p s0 -> stable q rel /\ witnessed #s #rel q /\ (q s0 ==> p () s0)))
(* Some sample code *)
let nat_rel' : relation nat
= fun i j -> i <= j
let nat_rel : preorder nat = nat_rel'
open FStar.Mul | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Monotonic.Witnessed.fsti.checked"
],
"interface_file": false,
"source_file": "IMST.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | _: Prims.unit -> IMST.IMST Prims.nat | IMST.IMST | [] | [] | [
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.nat",
"IMST.get",
"IMST.nat_rel",
"IMST.recall",
"IMST.put",
"FStar.Mul.op_Star",
"IMST.witness",
"Prims.op_Addition",
"IMST.op_Greater_Less",
"FStar.Pervasives.dfst",
"FStar.Preorder.preorder",
"Prims.Mkdtuple2",
"IMST.st_post",
"Prims.l_Forall",
"Prims.int",
"Prims.op_GreaterThanOrEqual",
"Prims.l_imp"
] | [] | false | true | false | false | false | let f () : IMST nat ((| nat, nat_rel |) >< (fun p s0 -> forall s1. s1 > s0 ==> p s0 s1)) =
| let s0 = get #nat #nat_rel () in
put #nat #nat_rel (s0 + 1);
let s1 = get #nat #nat_rel () in
assert (s1 > 0);
witness #nat #nat_rel (fun n -> n > 0);
put #nat #nat_rel (s1 * 42);
recall #nat #nat_rel (fun n -> n > 0);
let s2 = get #nat #nat_rel () in
assert (s2 > 0);
s0 | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.make_constant_size_parser_precond_precond | val make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
(s1: bytes{Seq.length s1 == sz})
(s2: bytes{Seq.length s2 == sz})
: GTot Type0 | val make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
(s1: bytes{Seq.length s1 == sz})
(s2: bytes{Seq.length s2 == sz})
: GTot Type0 | let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2 | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 49,
"start_col": 0,
"start_line": 42
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
sz: Prims.nat ->
t: Type0 ->
f:
(s: MiniParse.Spec.Base.bytes{FStar.Seq.Base.length s == sz}
-> Prims.GTot (FStar.Pervasives.Native.option t)) ->
s1: MiniParse.Spec.Base.bytes{FStar.Seq.Base.length s1 == sz} ->
s2: MiniParse.Spec.Base.bytes{FStar.Seq.Base.length s2 == sz}
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.nat",
"MiniParse.Spec.Base.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"MiniParse.Spec.Base.byte",
"FStar.Pervasives.Native.option",
"Prims.l_and",
"Prims.l_or",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some"
] | [] | false | false | false | false | true | let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
(s1: bytes{Seq.length s1 == sz})
(s2: bytes{Seq.length s2 == sz})
: GTot Type0 =
| (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2 | false |
IMST.fst | IMST.nat_rel | val nat_rel:preorder nat | val nat_rel:preorder nat | let nat_rel : preorder nat = nat_rel' | {
"file_name": "examples/indexed_effects/IMST.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 136,
"start_col": 0,
"start_line": 136
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 IMST
(* A proof-of-concept example of indexed effects (the state-and-preorder indexed MST effect) encoded using standard F* WP calculi *)
open FStar.Preorder
module W = FStar.Monotonic.Witnessed
(* The state-and-preorder indexed MST effect; defined explicitly rather than via DM4F due to the pi-types used in it *)
//s is at a fixed universe level (here #u0) because because otherwise sub_effect complains about being too universe polymorphic
let st_pre (s:Type0) = s -> GTot Type0
let st_post' (s:Type0) (a:Type) (pre:Type) = a -> (_:s{pre}) -> GTot Type0
let st_post (s:Type0) (a:Type) = st_post_h' s a True
let st_wp (a:Type) = s:Type0 -> (preorder s) -> st_post_h s a -> Tot (st_pre_h s)
unfold
let st_return (a:Type) (x:a) (s:Type0) (rel:preorder s) (post:st_post s a) (s0:s)
= forall v. v == x ==> post v s0
unfold
let st_bind (a:Type) (b:Type)
(wp1:st_wp a) (wp2: (a -> Tot (st_wp b)))
(s:Type0) (rel:preorder s) (post:st_post s b) (s0:s)
= wp1 s rel (fun x s1 -> wp2 x s rel post s1) s0
unfold
let st_if_then_else (a:Type) (p:Type)
(wp_then:st_wp a) (wp_else:st_wp a)
(s:Type0) (rel:preorder s) (post:st_post s a) (s0:s)
= l_ITE p (wp_then s rel post s0) (wp_else s rel post s0)
unfold
let st_ite (a:Type) (wp:st_wp a) (s:Type0) (rel:preorder s) (post:st_post s a) (s0:s)
= forall (k:st_post s a).
(forall (x:a) (s1:s).{:pattern (guard_free (k x s1))} post x s1 ==> k x s1)
==> wp s rel k s0
unfold
let st_stronger (a:Type) (wp1:st_wp a) (wp2:st_wp a)
= forall (s:Type0) (rel:preorder s) (p:st_post s a) (s0:s) . wp1 s rel p s0 ==> wp2 s rel p s0
unfold
let st_close (a:Type) (b:Type) (wp:(b -> GTot (st_wp a)))
(s:Type0) (rel:preorder s) (p:st_post s a) (s0:s)
= forall x. wp x s rel p s0
unfold
let st_trivial (a:Type) (wp:st_wp a)
= forall s rel s0. wp s rel (fun _ _ -> True) s0
new_effect {
IMST : result:Type -> wp:st_wp result -> Effect
with
//repr = s:Type0 -> preorder s -> s -> M (a * s) // - pi-types currently not supported by DM4F
//repr' = s:Type0 -> rel:preorder s -> s0:s -> M (a * s1:s{rel s0 s1})
// - pi-types currently not supported by DM4F;
// refinement types also currently not supported by DM4F
return_wp = st_return
; bind_wp = st_bind
; if_then_else = st_if_then_else
; ite_wp = st_ite
; stronger = st_stronger
; close_wp = st_close
; trivial = st_trivial
}
// For effects where subtyping parameters is sound, e.g.,
//
// exn:Type -> exns:set exn -> M (either a e:exn{mem e exns})
//
// there is also the problem of needing to subtype postconditions according to the chosen (subset) order on exns.
//
// The precise typing would (highly likely) be needed to ensure that reification/reflection are sound.
(* Standard lifting *)
unfold
let lift_div_imst (a:Type) (wp:pure_wp a) (s:Type0)
(rel:preorder s) (post:st_post s a) (s0:s)
= wp (fun x -> post x s0)
sub_effect DIV ~> IMST = lift_div_imst
(* Non-indexed MST WPs and syntactic sugar for writing effect indices *)
let st_wp' (a:Type) (s:Type0)
= st_post s a -> Tot (st_pre s)
unfold
let (><) (#a:Type) (sr:(s:Type0 & preorder s)) (wp:st_wp' a (dfst sr)) : st_wp a
= fun s rel post s0 -> s == dfst sr /\ (forall x y . rel x y <==> dsnd sr x y) /\ wp post s0
(* Standard, but now state-and-preorder indexed get, put, witness, and recall actions *)
assume val get (#s:Type0) (#rel:preorder s) (_:unit) : IMST s ((|s , rel|) >< (fun p s0 -> p s0 s0))
assume val put (#s:Type0) (#rel:preorder s) (s1:s) : IMST unit ((|s , rel|) >< (fun p s0 -> rel s0 s1 /\ p () s1))
let witnessed (#s:Type) (#rel:preorder s) (p:predicate s) :Type0 = W.witnessed rel p
assume val witness (#s:Type) (#rel:preorder s) (q:predicate s)
: IMST unit ((|s , rel|) >< (fun p s0 -> stable q rel /\ q s0 /\ (witnessed #s #rel q ==> p () s0)))
assume val recall (#s:Type) (#rel:preorder s) (q:predicate s)
: IMST unit ((|s , rel|) >< (fun p s0 -> stable q rel /\ witnessed #s #rel q /\ (q s0 ==> p () s0)))
(* Some sample code *)
let nat_rel' : relation nat
= fun i j -> i <= j | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Monotonic.Witnessed.fsti.checked"
],
"interface_file": false,
"source_file": "IMST.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": "W"
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | FStar.Preorder.preorder Prims.nat | Prims.Tot | [
"total"
] | [] | [
"IMST.nat_rel'"
] | [] | false | false | false | true | false | let nat_rel:preorder nat =
| nat_rel' | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.make_constant_size_parser_precond | val make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: GTot Type0 | val make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: GTot Type0 | let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2 | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 78,
"end_line": 57,
"start_col": 0,
"start_line": 51
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
sz: Prims.nat ->
t: Type0 ->
f:
(s: MiniParse.Spec.Base.bytes{FStar.Seq.Base.length s == sz}
-> Prims.GTot (FStar.Pervasives.Native.option t))
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.nat",
"MiniParse.Spec.Base.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"MiniParse.Spec.Base.byte",
"FStar.Pervasives.Native.option",
"Prims.l_Forall",
"Prims.l_imp",
"MiniParse.Spec.Combinators.make_constant_size_parser_precond_precond",
"FStar.Seq.Base.equal"
] | [] | false | false | false | false | true | let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: GTot Type0 =
| forall (s1: bytes{Seq.length s1 == sz}) (s2: bytes{Seq.length s2 == sz}).
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2 | false |
Hacl.Bignum.Convert.fst | Hacl.Bignum.Convert.bn_to_bytes_be_ | val bn_to_bytes_be_:
#t:limb_t
-> len:size_t{numbytes t * v len <= max_size_t}
-> b:lbignum t len
-> res:lbuffer uint8 (size (numbytes t) *! len) ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_to_bytes_be_ (v len) (as_seq h0 b)) | val bn_to_bytes_be_:
#t:limb_t
-> len:size_t{numbytes t * v len <= max_size_t}
-> b:lbignum t len
-> res:lbuffer uint8 (size (numbytes t) *! len) ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_to_bytes_be_ (v len) (as_seq h0 b)) | let bn_to_bytes_be_ #t len b res =
[@inline_let] let numb = size (numbytes t) in
let h0 = ST.get () in
[@ inline_let]
let a_spec (i:nat{i <= v len}) = unit in
[@ inline_let]
let spec (h:mem) = S.bn_to_bytes_be_f (v len) (as_seq h b) in
fill_blocks h0 numb len res a_spec (fun _ _ -> ()) (fun _ -> LowStar.Buffer.loc_none) spec
(fun j -> uint_to_bytes_be (sub res (j *! numb) numb) b.(len -! j -! 1ul));
norm_spec [delta_only [`%S.bn_to_bytes_be_]] (S.bn_to_bytes_be_ (v len) (as_seq h0 b)) | {
"file_name": "code/bignum/Hacl.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 88,
"end_line": 172,
"start_col": 0,
"start_line": 163
} | module Hacl.Bignum.Convert
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Hacl.Spec.Bignum.Convert
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val bn_from_uint:
#t:limb_t
-> len:size_t{0 < v len}
-> x:limb t
-> b:lbignum t len ->
Stack unit
(requires fun h -> live h b)
(ensures fun h0 _ h1 -> modifies (loc b) h0 h1 /\
as_seq h1 b == S.bn_from_uint (v len) x)
let bn_from_uint #t len x b =
memset b (uint #t 0) len;
b.(0ul) <- x
inline_for_extraction noextract
val bn_from_bytes_be_:
#t:limb_t
-> len:size_t{numbytes t * v len <= max_size_t}
-> b:lbuffer uint8 (size (numbytes t) *! len)
-> res:lbignum t len ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_from_bytes_be_ (v len) (as_seq h0 b))
let bn_from_bytes_be_ #t len b res =
let h0 = ST.get () in
[@inline_let]
let spec h = S.bn_from_bytes_be_f (v len) (as_seq h b) in
fill h0 len res spec
(fun j -> uint_from_bytes_be (sub b ((len -! j -! 1ul) *! (size (numbytes t))) (size (numbytes t))))
inline_for_extraction noextract
let bn_from_bytes_be_st (t:limb_t) =
len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t}
-> b:lbuffer uint8 len
-> res:lbignum t (blocks len (size (numbytes t))) ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_from_bytes_be (v len) (as_seq h0 b))
inline_for_extraction noextract
val mk_bn_from_bytes_be: #t:limb_t -> is_known_len:bool -> bn_from_bytes_be_st t
let mk_bn_from_bytes_be #t is_known_len len b res =
push_frame ();
if is_known_len then begin
[@inline_let] let numb = size (numbytes t) in
[@inline_let] let bnLen = blocks len numb in
[@inline_let] let tmpLen = numb *! bnLen in
if tmpLen =. len then
bn_from_bytes_be_ bnLen b res
else begin
let tmp = create tmpLen (u8 0) in
update_sub tmp (tmpLen -! len) len b;
bn_from_bytes_be_ bnLen tmp res end end
else begin
[@inline_let] let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
update_sub tmp (tmpLen -! len) len b;
bn_from_bytes_be_ bnLen tmp res end;
pop_frame ()
[@CInline]
let bn_from_bytes_be_uint32 : bn_from_bytes_be_st U32 = mk_bn_from_bytes_be #U32 false
let bn_from_bytes_be_uint64 : bn_from_bytes_be_st U64 = mk_bn_from_bytes_be #U64 false
inline_for_extraction noextract
val bn_from_bytes_be: #t:limb_t -> bn_from_bytes_be_st t
let bn_from_bytes_be #t =
match t with
| U32 -> bn_from_bytes_be_uint32
| U64 -> bn_from_bytes_be_uint64
inline_for_extraction noextract
let bn_from_bytes_le_st (t:limb_t) =
len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t}
-> b:lbuffer uint8 len
-> res:lbignum t (blocks len (size (numbytes t))) ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_from_bytes_le (v len) (as_seq h0 b))
inline_for_extraction noextract
val mk_bn_from_bytes_le: #t:limb_t -> is_known_len:bool -> bn_from_bytes_le_st t
let mk_bn_from_bytes_le #t is_known_len len b res =
push_frame ();
if is_known_len then begin
[@inline_let] let numb = size (numbytes t) in
[@inline_let] let bnLen = blocks len numb in
[@inline_let] let tmpLen = numb *! bnLen in
if tmpLen =. len then
uints_from_bytes_le res b
else begin
let tmp = create tmpLen (u8 0) in
update_sub tmp 0ul len b;
uints_from_bytes_le res tmp end end
else begin
[@inline_let] let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
update_sub tmp 0ul len b;
uints_from_bytes_le res tmp end;
pop_frame ()
[@CInline]
let bn_from_bytes_le_uint32 : bn_from_bytes_le_st U32 = mk_bn_from_bytes_le #U32 false
[@CInline]
let bn_from_bytes_le_uint64 : bn_from_bytes_le_st U64 = mk_bn_from_bytes_le #U64 false
inline_for_extraction noextract
val bn_from_bytes_le: #t:limb_t -> bn_from_bytes_le_st t
let bn_from_bytes_le #t =
match t with
| U32 -> bn_from_bytes_le_uint32
| U64 -> bn_from_bytes_le_uint64
inline_for_extraction noextract
val bn_to_bytes_be_:
#t:limb_t
-> len:size_t{numbytes t * v len <= max_size_t}
-> b:lbignum t len
-> res:lbuffer uint8 (size (numbytes t) *! len) ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_to_bytes_be_ (v len) (as_seq h0 b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Convert.fst.checked",
"Hacl.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.Convert.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Convert",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"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
}
] | {
"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"
} | false |
len:
Lib.IntTypes.size_t{Lib.IntTypes.numbytes t * Lib.IntTypes.v len <= Lib.IntTypes.max_size_t} ->
b: Hacl.Bignum.Definitions.lbignum t len ->
res: Lib.Buffer.lbuffer Lib.IntTypes.uint8 (Lib.IntTypes.size (Lib.IntTypes.numbytes t) *! len)
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.size",
"FStar.Pervasives.norm_spec",
"Prims.Cons",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.delta_only",
"Prims.string",
"Prims.Nil",
"Lib.Sequence.lseq",
"Hacl.Spec.Bignum.Convert.bn_to_bytes_be_",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Hacl.Bignum.Definitions.limb",
"Prims.unit",
"Lib.Buffer.fill_blocks",
"FStar.Monotonic.HyperStack.mem",
"Lib.IntTypes.size_nat",
"LowStar.Monotonic.Buffer.loc_none",
"LowStar.Monotonic.Buffer.loc",
"Prims.l_and",
"LowStar.Monotonic.Buffer.loc_disjoint",
"Lib.Buffer.loc",
"LowStar.Monotonic.Buffer.loc_includes",
"LowStar.Monotonic.Buffer.address_liveness_insensitive_locs",
"Prims.op_LessThan",
"Lib.ByteBuffer.uint_to_bytes_be",
"Lib.IntTypes.SEC",
"Lib.IntTypes.int_t",
"Lib.Buffer.op_Array_Access",
"Lib.IntTypes.op_Subtraction_Bang",
"FStar.UInt32.__uint_to_t",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.mk_int",
"Lib.Buffer.sub",
"Prims.nat",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Convert.bn_to_bytes_be_f",
"Prims.eqtype",
"FStar.HyperStack.ST.get"
] | [] | false | true | false | false | false | let bn_to_bytes_be_ #t len b res =
| [@@ inline_let ]let numb = size (numbytes t) in
let h0 = ST.get () in
[@@ inline_let ]let a_spec (i: nat{i <= v len}) = unit in
[@@ inline_let ]let spec (h: mem) = S.bn_to_bytes_be_f (v len) (as_seq h b) in
fill_blocks h0
numb
len
res
a_spec
(fun _ _ -> ())
(fun _ -> LowStar.Buffer.loc_none)
spec
(fun j -> uint_to_bytes_be (sub res (j *! numb) numb) b.(len -! j -! 1ul));
norm_spec [delta_only [`%S.bn_to_bytes_be_]] (S.bn_to_bytes_be_ (v len) (as_seq h0 b)) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.make_total_constant_size_parser_precond | val make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot t))
: GTot Type0 | val make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot t))
: GTot Type0 | let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2 | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 115,
"start_col": 0,
"start_line": 109
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
sz: Prims.nat ->
t: Type0 ->
f: (s: MiniParse.Spec.Base.bytes{FStar.Seq.Base.length s == sz} -> Prims.GTot t)
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.nat",
"MiniParse.Spec.Base.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"MiniParse.Spec.Base.byte",
"Prims.l_Forall",
"Prims.l_imp",
"FStar.Seq.Base.equal"
] | [] | false | false | false | false | true | let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot t))
: GTot Type0 =
| forall (s1: bytes{Seq.length s1 == sz}) (s2: bytes{Seq.length s2 == sz}).
f s1 == f s2 ==> Seq.equal s1 s2 | false |
Hacl.Bignum.Convert.fst | Hacl.Bignum.Convert.mk_bn_to_bytes_le | val mk_bn_to_bytes_le:
#t:limb_t
-> is_known_len:bool
-> len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t} ->
bn_to_bytes_le_st t len | val mk_bn_to_bytes_le:
#t:limb_t
-> is_known_len:bool
-> len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t} ->
bn_to_bytes_le_st t len | let mk_bn_to_bytes_le #t is_known_len len b res =
push_frame ();
if is_known_len then begin
[@inline_let] let numb = size (numbytes t) in
[@inline_let] let bnLen = blocks len numb in
[@inline_let] let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
if tmpLen =. len then begin
LowStar.Ignore.ignore tmp;
uints_to_bytes_le bnLen res b end
else begin
uints_to_bytes_le bnLen tmp b;
copy res (sub tmp 0ul len) end end
else begin
[@inline_let] let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
uints_to_bytes_le bnLen tmp b;
copy res (sub tmp 0ul len) end;
pop_frame () | {
"file_name": "code/bignum/Hacl.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 267,
"start_col": 0,
"start_line": 247
} | module Hacl.Bignum.Convert
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Hacl.Spec.Bignum.Convert
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val bn_from_uint:
#t:limb_t
-> len:size_t{0 < v len}
-> x:limb t
-> b:lbignum t len ->
Stack unit
(requires fun h -> live h b)
(ensures fun h0 _ h1 -> modifies (loc b) h0 h1 /\
as_seq h1 b == S.bn_from_uint (v len) x)
let bn_from_uint #t len x b =
memset b (uint #t 0) len;
b.(0ul) <- x
inline_for_extraction noextract
val bn_from_bytes_be_:
#t:limb_t
-> len:size_t{numbytes t * v len <= max_size_t}
-> b:lbuffer uint8 (size (numbytes t) *! len)
-> res:lbignum t len ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_from_bytes_be_ (v len) (as_seq h0 b))
let bn_from_bytes_be_ #t len b res =
let h0 = ST.get () in
[@inline_let]
let spec h = S.bn_from_bytes_be_f (v len) (as_seq h b) in
fill h0 len res spec
(fun j -> uint_from_bytes_be (sub b ((len -! j -! 1ul) *! (size (numbytes t))) (size (numbytes t))))
inline_for_extraction noextract
let bn_from_bytes_be_st (t:limb_t) =
len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t}
-> b:lbuffer uint8 len
-> res:lbignum t (blocks len (size (numbytes t))) ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_from_bytes_be (v len) (as_seq h0 b))
inline_for_extraction noextract
val mk_bn_from_bytes_be: #t:limb_t -> is_known_len:bool -> bn_from_bytes_be_st t
let mk_bn_from_bytes_be #t is_known_len len b res =
push_frame ();
if is_known_len then begin
[@inline_let] let numb = size (numbytes t) in
[@inline_let] let bnLen = blocks len numb in
[@inline_let] let tmpLen = numb *! bnLen in
if tmpLen =. len then
bn_from_bytes_be_ bnLen b res
else begin
let tmp = create tmpLen (u8 0) in
update_sub tmp (tmpLen -! len) len b;
bn_from_bytes_be_ bnLen tmp res end end
else begin
[@inline_let] let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
update_sub tmp (tmpLen -! len) len b;
bn_from_bytes_be_ bnLen tmp res end;
pop_frame ()
[@CInline]
let bn_from_bytes_be_uint32 : bn_from_bytes_be_st U32 = mk_bn_from_bytes_be #U32 false
let bn_from_bytes_be_uint64 : bn_from_bytes_be_st U64 = mk_bn_from_bytes_be #U64 false
inline_for_extraction noextract
val bn_from_bytes_be: #t:limb_t -> bn_from_bytes_be_st t
let bn_from_bytes_be #t =
match t with
| U32 -> bn_from_bytes_be_uint32
| U64 -> bn_from_bytes_be_uint64
inline_for_extraction noextract
let bn_from_bytes_le_st (t:limb_t) =
len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t}
-> b:lbuffer uint8 len
-> res:lbignum t (blocks len (size (numbytes t))) ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_from_bytes_le (v len) (as_seq h0 b))
inline_for_extraction noextract
val mk_bn_from_bytes_le: #t:limb_t -> is_known_len:bool -> bn_from_bytes_le_st t
let mk_bn_from_bytes_le #t is_known_len len b res =
push_frame ();
if is_known_len then begin
[@inline_let] let numb = size (numbytes t) in
[@inline_let] let bnLen = blocks len numb in
[@inline_let] let tmpLen = numb *! bnLen in
if tmpLen =. len then
uints_from_bytes_le res b
else begin
let tmp = create tmpLen (u8 0) in
update_sub tmp 0ul len b;
uints_from_bytes_le res tmp end end
else begin
[@inline_let] let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
update_sub tmp 0ul len b;
uints_from_bytes_le res tmp end;
pop_frame ()
[@CInline]
let bn_from_bytes_le_uint32 : bn_from_bytes_le_st U32 = mk_bn_from_bytes_le #U32 false
[@CInline]
let bn_from_bytes_le_uint64 : bn_from_bytes_le_st U64 = mk_bn_from_bytes_le #U64 false
inline_for_extraction noextract
val bn_from_bytes_le: #t:limb_t -> bn_from_bytes_le_st t
let bn_from_bytes_le #t =
match t with
| U32 -> bn_from_bytes_le_uint32
| U64 -> bn_from_bytes_le_uint64
inline_for_extraction noextract
val bn_to_bytes_be_:
#t:limb_t
-> len:size_t{numbytes t * v len <= max_size_t}
-> b:lbignum t len
-> res:lbuffer uint8 (size (numbytes t) *! len) ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_to_bytes_be_ (v len) (as_seq h0 b))
let bn_to_bytes_be_ #t len b res =
[@inline_let] let numb = size (numbytes t) in
let h0 = ST.get () in
[@ inline_let]
let a_spec (i:nat{i <= v len}) = unit in
[@ inline_let]
let spec (h:mem) = S.bn_to_bytes_be_f (v len) (as_seq h b) in
fill_blocks h0 numb len res a_spec (fun _ _ -> ()) (fun _ -> LowStar.Buffer.loc_none) spec
(fun j -> uint_to_bytes_be (sub res (j *! numb) numb) b.(len -! j -! 1ul));
norm_spec [delta_only [`%S.bn_to_bytes_be_]] (S.bn_to_bytes_be_ (v len) (as_seq h0 b))
inline_for_extraction noextract
let bn_to_bytes_be_st (t:limb_t) (len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t}) =
b:lbignum t (blocks len (size (numbytes t)))
-> res:lbuffer uint8 len ->
Stack unit
(requires fun h ->
live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_to_bytes_be (v len) (as_seq h0 b))
inline_for_extraction noextract
val mk_bn_to_bytes_be:
#t:limb_t
-> is_known_len:bool
-> len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t} ->
bn_to_bytes_be_st t len
let mk_bn_to_bytes_be #t is_known_len len b res =
push_frame ();
if is_known_len then begin
[@inline_let] let numb = size (numbytes t) in
[@inline_let] let bnLen = blocks len numb in
[@inline_let] let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
if tmpLen =. len then begin
LowStar.Ignore.ignore tmp;
bn_to_bytes_be_ bnLen b res end
else begin
HyperStack.ST.break_vc ();
bn_to_bytes_be_ bnLen b tmp;
copy res (sub tmp (tmpLen -! len) len) end end
else begin
[@inline_let] let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
bn_to_bytes_be_ bnLen b tmp;
copy res (sub tmp (tmpLen -! len) len) end;
pop_frame ()
[@CInline]
let bn_to_bytes_be_uint32 len : bn_to_bytes_be_st U32 len = mk_bn_to_bytes_be #U32 false len
let bn_to_bytes_be_uint64 len : bn_to_bytes_be_st U64 len = mk_bn_to_bytes_be #U64 false len
inline_for_extraction noextract
val bn_to_bytes_be: #t:_ -> len:_ -> bn_to_bytes_be_st t len
let bn_to_bytes_be #t =
match t with
| U32 -> bn_to_bytes_be_uint32
| U64 -> bn_to_bytes_be_uint64
inline_for_extraction noextract
let bn_to_bytes_le_st (t:limb_t) (len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t}) =
b:lbignum t (blocks len (size (numbytes t)))
-> res:lbuffer uint8 len ->
Stack unit
(requires fun h ->
live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_to_bytes_le (v len) (as_seq h0 b))
inline_for_extraction noextract
val mk_bn_to_bytes_le:
#t:limb_t
-> is_known_len:bool
-> len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t} ->
bn_to_bytes_le_st t len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Convert.fst.checked",
"Hacl.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.Convert.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Convert",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"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
}
] | {
"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"
} | false |
is_known_len: Prims.bool ->
len:
Lib.IntTypes.size_t
{ 0 < Lib.IntTypes.v len /\
Lib.IntTypes.numbytes t *
Lib.IntTypes.v (Hacl.Bignum.Definitions.blocks len
(Lib.IntTypes.size (Lib.IntTypes.numbytes t))) <=
Lib.IntTypes.max_size_t }
-> Hacl.Bignum.Convert.bn_to_bytes_le_st t len | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Prims.bool",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Lib.IntTypes.op_Equals_Dot",
"Lib.ByteBuffer.uints_to_bytes_le",
"Lib.IntTypes.SEC",
"LowStar.Ignore.ignore",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.Buffer.copy",
"Lib.Buffer.MUT",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.Buffer.sub",
"FStar.UInt32.__uint_to_t",
"Lib.Buffer.create",
"Lib.IntTypes.u8",
"Lib.IntTypes.op_Star_Bang",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.op_GreaterThan",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Definitions.blocks",
"FStar.HyperStack.ST.push_frame"
] | [] | false | false | false | false | false | let mk_bn_to_bytes_le #t is_known_len len b res =
| push_frame ();
if is_known_len
then
[@@ inline_let ]let numb = size (numbytes t) in
[@@ inline_let ]let bnLen = blocks len numb in
[@@ inline_let ]let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
if tmpLen =. len
then
(LowStar.Ignore.ignore tmp;
uints_to_bytes_le bnLen res b)
else
(uints_to_bytes_le bnLen tmp b;
copy res (sub tmp 0ul len))
else
([@@ inline_let ]let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
uints_to_bytes_le bnLen tmp b;
copy res (sub tmp 0ul len));
pop_frame () | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.fail_parser' | val fail_parser' (t: Type0) : Tot (bare_parser t) | val fail_parser' (t: Type0) : Tot (bare_parser t) | let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 149,
"start_col": 0,
"start_line": 146
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: Type0 -> MiniParse.Spec.Base.bare_parser t | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.bytes",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"MiniParse.Spec.Base.consumed_length",
"FStar.Pervasives.Native.option",
"MiniParse.Spec.Base.bare_parser"
] | [] | false | false | false | true | false | let fail_parser' (t: Type0) : Tot (bare_parser t) =
| fun _ -> None | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.parse_empty | val parse_empty:parser_spec unit | val parse_empty:parser_spec unit | let parse_empty : parser_spec unit =
parse_ret () | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 139,
"start_col": 0,
"start_line": 138
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | MiniParse.Spec.Base.parser_spec Prims.unit | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Combinators.parse_ret",
"Prims.unit"
] | [] | false | false | false | true | false | let parse_empty:parser_spec unit =
| parse_ret () | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.make_constant_size_parser_precond' | val make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: GTot Type0 | val make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: GTot Type0 | let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2 | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 71,
"end_line": 65,
"start_col": 0,
"start_line": 59
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
sz: Prims.nat ->
t: Type0 ->
f:
(s: MiniParse.Spec.Base.bytes{FStar.Seq.Base.length s == sz}
-> Prims.GTot (FStar.Pervasives.Native.option t))
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.nat",
"MiniParse.Spec.Base.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"MiniParse.Spec.Base.byte",
"FStar.Pervasives.Native.option",
"Prims.l_Forall",
"Prims.l_imp",
"MiniParse.Spec.Combinators.make_constant_size_parser_precond_precond",
"Prims.l_or"
] | [] | false | false | false | false | true | let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: GTot Type0 =
| forall (s1: bytes{Seq.length s1 == sz}) (s2: bytes{Seq.length s2 == sz}).
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2 | false |
Hacl.Impl.Ed25519.Ladder.fst | Hacl.Impl.Ed25519.Ladder.lemma_exp_four_fw_local | val lemma_exp_four_fw_local: b:BSeq.lbytes 32 ->
Lemma (let bn = BSeq.nat_from_bytes_le b in
let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 bn in
let cm = S.mk_ed25519_comm_monoid in
LE.exp_four_fw cm g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 ==
S.to_aff_point (S.point_mul_g b)) | val lemma_exp_four_fw_local: b:BSeq.lbytes 32 ->
Lemma (let bn = BSeq.nat_from_bytes_le b in
let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 bn in
let cm = S.mk_ed25519_comm_monoid in
LE.exp_four_fw cm g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 ==
S.to_aff_point (S.point_mul_g b)) | let lemma_exp_four_fw_local b =
let bn = BSeq.nat_from_bytes_le b in
let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 bn in
let cm = S.mk_ed25519_comm_monoid in
let res = LE.exp_four_fw cm g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 in
assert (res == SPT256.exp_as_exp_four_nat256_precomp cm g_aff bn);
SPT256.lemma_point_mul_base_precomp4 cm g_aff bn;
assert (res == LE.pow cm g_aff bn);
SE.exp_fw_lemma S.mk_ed25519_concrete_ops g_c 256 bn 4;
LE.exp_fw_lemma cm g_aff 256 bn 4;
assert (S.to_aff_point (S.point_mul_g b) == LE.pow cm g_aff bn) | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Ladder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 65,
"end_line": 235,
"start_col": 0,
"start_line": 225
} | module Hacl.Impl.Ed25519.Ladder
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module BSeq = Lib.ByteSequence
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExponentiation
module PT = Hacl.Impl.PrecompTable
module SPT256 = Hacl.Spec.PrecompBaseTable256
module BD = Hacl.Bignum.Definitions
module SD = Hacl.Spec.Bignum.Definitions
module S = Spec.Ed25519
open Hacl.Impl.Ed25519.PointConstants
include Hacl.Impl.Ed25519.Group
include Hacl.Ed25519.PrecompTable
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let table_inv_w4 : BE.table_inv_t U64 20ul 16ul =
[@inline_let] let len = 20ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_ed25519_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len
inline_for_extraction noextract
let table_inv_w5 : BE.table_inv_t U64 20ul 32ul =
[@inline_let] let len = 20ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_ed25519_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
assert_norm (pow2 (v l) = v table_len);
BE.table_inv_precomp len ctx_len k l table_len
inline_for_extraction noextract
val convert_scalar: scalar:lbuffer uint8 32ul -> bscalar:lbuffer uint64 4ul ->
Stack unit
(requires fun h -> live h scalar /\ live h bscalar /\ disjoint scalar bscalar)
(ensures fun h0 _ h1 -> modifies (loc bscalar) h0 h1 /\
BD.bn_v h1 bscalar == BSeq.nat_from_bytes_le (as_seq h0 scalar))
let convert_scalar scalar bscalar =
let h0 = ST.get () in
Hacl.Spec.Bignum.Convert.bn_from_bytes_le_lemma #U64 32 (as_seq h0 scalar);
Hacl.Bignum.Convert.mk_bn_from_bytes_le true 32ul scalar bscalar
inline_for_extraction noextract
val point_mul_noalloc:
out:point
-> bscalar:lbuffer uint64 4ul
-> q:point ->
Stack unit
(requires fun h ->
live h bscalar /\ live h q /\ live h out /\
disjoint q out /\ disjoint q bscalar /\ disjoint out bscalar /\
F51.point_inv_t h q /\ F51.inv_ext_point (as_seq h q) /\
BD.bn_v h bscalar < pow2 256)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
F51.point_inv_t h1 out /\ F51.inv_ext_point (as_seq h1 out) /\
S.to_aff_point (F51.point_eval h1 out) ==
LE.exp_fw S.mk_ed25519_comm_monoid
(S.to_aff_point (F51.point_eval h0 q)) 256 (BD.bn_v h0 bscalar) 4)
let point_mul_noalloc out bscalar q =
BE.lexp_fw_consttime 20ul 0ul mk_ed25519_concrete_ops
4ul (null uint64) q 4ul 256ul bscalar out
let point_mul out scalar q =
let h0 = ST.get () in
SE.exp_fw_lemma S.mk_ed25519_concrete_ops
(F51.point_eval h0 q) 256 (BSeq.nat_from_bytes_le (as_seq h0 scalar)) 4;
push_frame ();
let bscalar = create 4ul (u64 0) in
convert_scalar scalar bscalar;
point_mul_noalloc out bscalar q;
pop_frame ()
val precomp_get_consttime: BE.pow_a_to_small_b_st U64 20ul 0ul mk_ed25519_concrete_ops 4ul 16ul
(BE.table_inv_precomp 20ul 0ul mk_ed25519_concrete_ops 4ul 16ul)
[@CInline]
let precomp_get_consttime ctx a table bits_l tmp =
[@inline_let] let len = 20ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_ed25519_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.lprecomp_get_consttime len ctx_len k l table_len ctx a table bits_l tmp
inline_for_extraction noextract
val point_mul_g_noalloc: out:point -> bscalar:lbuffer uint64 4ul
-> q1:point -> q2:point
-> q3:point -> q4:point ->
Stack unit
(requires fun h ->
live h bscalar /\ live h out /\ live h q1 /\
live h q2 /\ live h q3 /\ live h q4 /\
disjoint out bscalar /\ disjoint out q1 /\ disjoint out q2 /\
disjoint out q3 /\ disjoint out q4 /\
disjoint q1 q2 /\ disjoint q1 q3 /\ disjoint q1 q4 /\
disjoint q2 q3 /\ disjoint q2 q4 /\ disjoint q3 q4 /\
BD.bn_v h bscalar < pow2 256 /\
F51.linv (as_seq h q1) /\ refl (as_seq h q1) == g_aff /\
F51.linv (as_seq h q2) /\ refl (as_seq h q2) == g_pow2_64 /\
F51.linv (as_seq h q3) /\ refl (as_seq h q3) == g_pow2_128 /\
F51.linv (as_seq h q4) /\ refl (as_seq h q4) == g_pow2_192)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
F51.linv (as_seq h1 out) /\
(let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v h0 bscalar) in
S.to_aff_point (F51.point_eval h1 out) ==
LE.exp_four_fw S.mk_ed25519_comm_monoid
g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4))
let point_mul_g_noalloc out bscalar q1 q2 q3 q4 =
[@inline_let] let len = 20ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_ed25519_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
[@inline_let] let bLen = 1ul in
[@inline_let] let bBits = 64ul in
let h0 = ST.get () in
recall_contents precomp_basepoint_table_w4 precomp_basepoint_table_lseq_w4;
let h1 = ST.get () in
precomp_basepoint_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q1) (as_seq h1 precomp_basepoint_table_w4));
recall_contents precomp_g_pow2_64_table_w4 precomp_g_pow2_64_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_64_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q2) (as_seq h1 precomp_g_pow2_64_table_w4));
recall_contents precomp_g_pow2_128_table_w4 precomp_g_pow2_128_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_128_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q3) (as_seq h1 precomp_g_pow2_128_table_w4));
recall_contents precomp_g_pow2_192_table_w4 precomp_g_pow2_192_table_lseq_w4;
let h1 = ST.get () in
precomp_g_pow2_192_table_lemma_w4 ();
assert (table_inv_w4 (as_seq h1 q4) (as_seq h1 precomp_g_pow2_192_table_w4));
let r1 = sub bscalar 0ul 1ul in
let r2 = sub bscalar 1ul 1ul in
let r3 = sub bscalar 2ul 1ul in
let r4 = sub bscalar 3ul 1ul in
SPT256.lemma_decompose_nat256_as_four_u64_lbignum (as_seq h0 bscalar);
ME.mk_lexp_four_fw_tables len ctx_len k l table_len
table_inv_w4 table_inv_w4 table_inv_w4 table_inv_w4
precomp_get_consttime
precomp_get_consttime
precomp_get_consttime
precomp_get_consttime
(null uint64) q1 bLen bBits r1 q2 r2 q3 r3 q4 r4
(to_const precomp_basepoint_table_w4)
(to_const precomp_g_pow2_64_table_w4)
(to_const precomp_g_pow2_128_table_w4)
(to_const precomp_g_pow2_192_table_w4)
out;
LowStar.Ignore.ignore q2; // q2, q3, q4 are unused variables
LowStar.Ignore.ignore q3;
LowStar.Ignore.ignore q4
inline_for_extraction noextract
val point_mul_g_mk_q1234: out:point -> bscalar:lbuffer uint64 4ul -> q1:point ->
Stack unit
(requires fun h ->
live h bscalar /\ live h out /\ live h q1 /\
disjoint out bscalar /\ disjoint out q1 /\
BD.bn_v h bscalar < pow2 256 /\
F51.linv (as_seq h q1) /\ refl (as_seq h q1) == g_aff)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
F51.linv (as_seq h1 out) /\
(let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v h0 bscalar) in
S.to_aff_point (F51.point_eval h1 out) ==
LE.exp_four_fw S.mk_ed25519_comm_monoid
g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4))
let point_mul_g_mk_q1234 out bscalar q1 =
push_frame ();
let q2 = mk_ext_g_pow2_64 () in
let q3 = mk_ext_g_pow2_128 () in
let q4 = mk_ext_g_pow2_192 () in
ext_g_pow2_64_lseq_lemma ();
ext_g_pow2_128_lseq_lemma ();
ext_g_pow2_192_lseq_lemma ();
point_mul_g_noalloc out bscalar q1 q2 q3 q4;
pop_frame ()
val lemma_exp_four_fw_local: b:BSeq.lbytes 32 ->
Lemma (let bn = BSeq.nat_from_bytes_le b in
let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 bn in
let cm = S.mk_ed25519_comm_monoid in
LE.exp_four_fw cm g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 ==
S.to_aff_point (S.point_mul_g b)) | {
"checked_file": "/",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable256.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Convert.fst.checked",
"Hacl.Impl.PrecompTable.fsti.checked",
"Hacl.Impl.MultiExponentiation.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"Hacl.Impl.Ed25519.PointNegate.fst.checked",
"Hacl.Impl.Ed25519.PointConstants.fst.checked",
"Hacl.Impl.Ed25519.Group.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Ed25519.PrecompTable.fsti.checked",
"Hacl.Bignum25519.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Convert.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Impl.Ed25519.Ladder.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Ed25519.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.PointConstants",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.PrecompTable",
"short_module": "PT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.MultiExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"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
}
] | {
"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"
} | false | b: Lib.ByteSequence.lbytes 32
-> FStar.Pervasives.Lemma
(ensures
(let bn = Lib.ByteSequence.nat_from_bytes_le b in
let _ = Hacl.Spec.PrecompBaseTable256.decompose_nat256_as_four_u64 bn in
(let FStar.Pervasives.Native.Mktuple4 #_ #_ #_ #_ b0 b1 b2 b3 = _ in
let cm = Spec.Ed25519.mk_ed25519_comm_monoid in
Lib.Exponentiation.exp_four_fw cm Hacl.Ed25519.PrecompTable.g_aff 64 b0
Hacl.Ed25519.PrecompTable.g_pow2_64 b1 Hacl.Ed25519.PrecompTable.g_pow2_128 b2
Hacl.Ed25519.PrecompTable.g_pow2_192 b3 4 ==
Spec.Ed25519.PointOps.to_aff_point (Spec.Ed25519.point_mul_g b))
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.ByteSequence.lbytes",
"Prims.int",
"Prims._assert",
"Prims.eq2",
"Spec.Ed25519.PointOps.aff_point",
"Spec.Ed25519.PointOps.to_aff_point",
"Spec.Ed25519.point_mul_g",
"Lib.Exponentiation.Definition.pow",
"Spec.Ed25519.aff_point_c",
"Hacl.Ed25519.PrecompTable.g_aff",
"Prims.unit",
"Lib.Exponentiation.exp_fw_lemma",
"Spec.Exponentiation.exp_fw_lemma",
"Spec.Ed25519.ext_point_c",
"Spec.Ed25519.mk_ed25519_concrete_ops",
"Hacl.Ed25519.PrecompTable.g_c",
"Hacl.Spec.PrecompBaseTable256.lemma_point_mul_base_precomp4",
"Hacl.Spec.PrecompBaseTable256.exp_as_exp_four_nat256_precomp",
"Lib.Exponentiation.exp_four_fw",
"Hacl.Ed25519.PrecompTable.g_pow2_64",
"Hacl.Ed25519.PrecompTable.g_pow2_128",
"Hacl.Ed25519.PrecompTable.g_pow2_192",
"Lib.Exponentiation.Definition.comm_monoid",
"Spec.Ed25519.mk_ed25519_comm_monoid",
"FStar.Pervasives.Native.tuple4",
"Hacl.Spec.PrecompBaseTable256.decompose_nat256_as_four_u64",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Multiply",
"Lib.Sequence.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.ByteSequence.nat_from_bytes_le"
] | [] | false | false | true | false | false | let lemma_exp_four_fw_local b =
| let bn = BSeq.nat_from_bytes_le b in
let b0, b1, b2, b3 = SPT256.decompose_nat256_as_four_u64 bn in
let cm = S.mk_ed25519_comm_monoid in
let res = LE.exp_four_fw cm g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 in
assert (res == SPT256.exp_as_exp_four_nat256_precomp cm g_aff bn);
SPT256.lemma_point_mul_base_precomp4 cm g_aff bn;
assert (res == LE.pow cm g_aff bn);
SE.exp_fw_lemma S.mk_ed25519_concrete_ops g_c 256 bn 4;
LE.exp_fw_lemma cm g_aff 256 bn 4;
assert (S.to_aff_point (S.point_mul_g b) == LE.pow cm g_aff bn) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.and_then_cases_injective | val and_then_cases_injective (#t #t': Type) (p': (t -> Tot (parser_spec t'))) : GTot Type0 | val and_then_cases_injective (#t #t': Type) (p': (t -> Tot (parser_spec t'))) : GTot Type0 | let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p') | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 60,
"end_line": 288,
"start_col": 0,
"start_line": 283
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p': (_: t -> MiniParse.Spec.Base.parser_spec t') -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Combinators.and_then_cases_injective'",
"MiniParse.Spec.Combinators.coerce_to_bare_param_parser"
] | [] | false | false | false | false | true | let and_then_cases_injective (#t #t': Type) (p': (t -> Tot (parser_spec t'))) : GTot Type0 =
| and_then_cases_injective' (coerce_to_bare_param_parser p') | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.and_then_cases_injective' | val and_then_cases_injective' (#t #t': Type) (p': (t -> Tot (bare_parser t'))) : GTot Type0 | val and_then_cases_injective' (#t #t': Type) (p': (t -> Tot (bare_parser t'))) : GTot Type0 | let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2 | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 10,
"end_line": 273,
"start_col": 0,
"start_line": 266
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p': (_: t -> MiniParse.Spec.Base.bare_parser t') -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"MiniParse.Spec.Base.bare_parser",
"Prims.l_Forall",
"MiniParse.Spec.Base.bytes",
"Prims.l_imp",
"MiniParse.Spec.Combinators.and_then_cases_injective_precond",
"Prims.eq2"
] | [] | false | false | false | false | true | let and_then_cases_injective' (#t #t': Type) (p': (t -> Tot (bare_parser t'))) : GTot Type0 =
| forall (x1: t) (x2: t) (b1: bytes) (b2: bytes).
and_then_cases_injective_precond p' x1 x2 b1 b2 ==> x1 == x2 | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.make_constant_size_parser_injective | val make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Lemma (requires (make_constant_size_parser_precond sz t f))
(ensures (injective (make_constant_size_parser_aux sz t f))) | val make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Lemma (requires (make_constant_size_parser_precond sz t f))
(ensures (injective (make_constant_size_parser_aux sz t f))) | let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1)) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 81,
"end_line": 94,
"start_col": 0,
"start_line": 67
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
sz: Prims.nat ->
t: Type0 ->
f:
(s: MiniParse.Spec.Base.bytes{FStar.Seq.Base.length s == sz}
-> Prims.GTot (FStar.Pervasives.Native.option t))
-> FStar.Pervasives.Lemma
(requires MiniParse.Spec.Combinators.make_constant_size_parser_precond sz t f)
(ensures
MiniParse.Spec.Base.injective (MiniParse.Spec.Combinators.make_constant_size_parser_aux sz
t
f)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"MiniParse.Spec.Base.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"MiniParse.Spec.Base.byte",
"FStar.Pervasives.Native.option",
"FStar.Classical.forall_intro_2",
"Prims.l_imp",
"MiniParse.Spec.Base.injective_precond",
"MiniParse.Spec.Base.injective_postcond",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"MiniParse.Spec.Base.consumed_length",
"Prims._assert",
"MiniParse.Spec.Combinators.make_constant_size_parser_precond'",
"MiniParse.Spec.Combinators.make_constant_size_parser_precond_precond",
"FStar.Seq.Base.slice",
"FStar.Pervasives.Native.tuple2",
"MiniParse.Spec.Base.bparse",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"MiniParse.Spec.Base.bare_parser",
"MiniParse.Spec.Combinators.make_constant_size_parser_aux",
"MiniParse.Spec.Combinators.make_constant_size_parser_precond",
"MiniParse.Spec.Base.injective"
] | [] | false | false | true | false | false | let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Lemma (requires (make_constant_size_parser_precond sz t f))
(ensures (injective (make_constant_size_parser_aux sz t f))) =
| let p:bare_parser t = make_constant_size_parser_aux sz t f in
let prf1 (b1 b2: bytes)
: Lemma (requires (injective_precond p b1 b2)) (ensures (injective_postcond p b1 b2)) =
assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let Some (v1, len1) = bparse p b1 in
let Some (v2, len2) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz
t
f
(Seq.slice b1 0 len1)
(Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1)) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.coerce_to_bare_param_parser | val coerce_to_bare_param_parser (#t #t': Type) (p': (t -> Tot (parser_spec t'))) (x: t)
: Tot (bare_parser t') | val coerce_to_bare_param_parser (#t #t': Type) (p': (t -> Tot (parser_spec t'))) (x: t)
: Tot (bare_parser t') | let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 281,
"start_col": 0,
"start_line": 275
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p': (_: t -> MiniParse.Spec.Base.parser_spec t') -> x: t -> MiniParse.Spec.Base.bare_parser t' | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Base.coerce_to_bare_parser",
"MiniParse.Spec.Base.bare_parser"
] | [] | false | false | false | true | false | let coerce_to_bare_param_parser (#t #t': Type) (p': (t -> Tot (parser_spec t'))) (x: t)
: Tot (bare_parser t') =
| coerce_to_bare_parser _ (p' x) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.make_constant_size_parser_aux | val make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Tot (bare_parser t) | val make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Tot (bare_parser t) | let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 40,
"start_col": 0,
"start_line": 25
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
sz: Prims.nat ->
t: Type0 ->
f:
(s: MiniParse.Spec.Base.bytes{FStar.Seq.Base.length s == sz}
-> Prims.GTot (FStar.Pervasives.Native.option t))
-> MiniParse.Spec.Base.bare_parser t | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"MiniParse.Spec.Base.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"MiniParse.Spec.Base.byte",
"FStar.Pervasives.Native.option",
"Prims.op_LessThan",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"MiniParse.Spec.Base.consumed_length",
"Prims.bool",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Base.slice",
"MiniParse.Spec.Base.bare_parser"
] | [] | false | false | false | false | false | let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Tot (bare_parser t) =
| fun (s: bytes) ->
if Seq.length s < sz
then None
else
let s':bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let sz:consumed_length s = sz in
Some (v, sz) | false |
Hacl.Bignum.Convert.fst | Hacl.Bignum.Convert.mk_bn_from_bytes_le | val mk_bn_from_bytes_le: #t:limb_t -> is_known_len:bool -> bn_from_bytes_le_st t | val mk_bn_from_bytes_le: #t:limb_t -> is_known_len:bool -> bn_from_bytes_le_st t | let mk_bn_from_bytes_le #t is_known_len len b res =
push_frame ();
if is_known_len then begin
[@inline_let] let numb = size (numbytes t) in
[@inline_let] let bnLen = blocks len numb in
[@inline_let] let tmpLen = numb *! bnLen in
if tmpLen =. len then
uints_from_bytes_le res b
else begin
let tmp = create tmpLen (u8 0) in
update_sub tmp 0ul len b;
uints_from_bytes_le res tmp end end
else begin
[@inline_let] let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
update_sub tmp 0ul len b;
uints_from_bytes_le res tmp end;
pop_frame () | {
"file_name": "code/bignum/Hacl.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 135,
"start_col": 0,
"start_line": 116
} | module Hacl.Bignum.Convert
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Hacl.Spec.Bignum.Convert
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val bn_from_uint:
#t:limb_t
-> len:size_t{0 < v len}
-> x:limb t
-> b:lbignum t len ->
Stack unit
(requires fun h -> live h b)
(ensures fun h0 _ h1 -> modifies (loc b) h0 h1 /\
as_seq h1 b == S.bn_from_uint (v len) x)
let bn_from_uint #t len x b =
memset b (uint #t 0) len;
b.(0ul) <- x
inline_for_extraction noextract
val bn_from_bytes_be_:
#t:limb_t
-> len:size_t{numbytes t * v len <= max_size_t}
-> b:lbuffer uint8 (size (numbytes t) *! len)
-> res:lbignum t len ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_from_bytes_be_ (v len) (as_seq h0 b))
let bn_from_bytes_be_ #t len b res =
let h0 = ST.get () in
[@inline_let]
let spec h = S.bn_from_bytes_be_f (v len) (as_seq h b) in
fill h0 len res spec
(fun j -> uint_from_bytes_be (sub b ((len -! j -! 1ul) *! (size (numbytes t))) (size (numbytes t))))
inline_for_extraction noextract
let bn_from_bytes_be_st (t:limb_t) =
len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t}
-> b:lbuffer uint8 len
-> res:lbignum t (blocks len (size (numbytes t))) ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_from_bytes_be (v len) (as_seq h0 b))
inline_for_extraction noextract
val mk_bn_from_bytes_be: #t:limb_t -> is_known_len:bool -> bn_from_bytes_be_st t
let mk_bn_from_bytes_be #t is_known_len len b res =
push_frame ();
if is_known_len then begin
[@inline_let] let numb = size (numbytes t) in
[@inline_let] let bnLen = blocks len numb in
[@inline_let] let tmpLen = numb *! bnLen in
if tmpLen =. len then
bn_from_bytes_be_ bnLen b res
else begin
let tmp = create tmpLen (u8 0) in
update_sub tmp (tmpLen -! len) len b;
bn_from_bytes_be_ bnLen tmp res end end
else begin
[@inline_let] let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
update_sub tmp (tmpLen -! len) len b;
bn_from_bytes_be_ bnLen tmp res end;
pop_frame ()
[@CInline]
let bn_from_bytes_be_uint32 : bn_from_bytes_be_st U32 = mk_bn_from_bytes_be #U32 false
let bn_from_bytes_be_uint64 : bn_from_bytes_be_st U64 = mk_bn_from_bytes_be #U64 false
inline_for_extraction noextract
val bn_from_bytes_be: #t:limb_t -> bn_from_bytes_be_st t
let bn_from_bytes_be #t =
match t with
| U32 -> bn_from_bytes_be_uint32
| U64 -> bn_from_bytes_be_uint64
inline_for_extraction noextract
let bn_from_bytes_le_st (t:limb_t) =
len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t}
-> b:lbuffer uint8 len
-> res:lbignum t (blocks len (size (numbytes t))) ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_from_bytes_le (v len) (as_seq h0 b))
inline_for_extraction noextract | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Convert.fst.checked",
"Hacl.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.Convert.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Convert",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"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
}
] | {
"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"
} | false | is_known_len: Prims.bool -> Hacl.Bignum.Convert.bn_from_bytes_le_st t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Prims.bool",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.IntTypes.max_size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.Bignum.Definitions.lbignum",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Lib.IntTypes.op_Equals_Dot",
"Lib.ByteBuffer.uints_from_bytes_le",
"Lib.IntTypes.SEC",
"Lib.Buffer.update_sub",
"Lib.Buffer.MUT",
"FStar.UInt32.__uint_to_t",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.Buffer.create",
"Lib.IntTypes.u8",
"Lib.IntTypes.op_Star_Bang",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.op_GreaterThan",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Definitions.blocks",
"FStar.HyperStack.ST.push_frame"
] | [] | false | false | false | false | false | let mk_bn_from_bytes_le #t is_known_len len b res =
| push_frame ();
if is_known_len
then
[@@ inline_let ]let numb = size (numbytes t) in
[@@ inline_let ]let bnLen = blocks len numb in
[@@ inline_let ]let tmpLen = numb *! bnLen in
if tmpLen =. len
then uints_from_bytes_le res b
else
let tmp = create tmpLen (u8 0) in
update_sub tmp 0ul len b;
uints_from_bytes_le res tmp
else
([@@ inline_let ]let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
update_sub tmp 0ul len b;
uints_from_bytes_le res tmp);
pop_frame () | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.make_total_constant_size_parser | val make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot t))
: Pure (parser_spec t)
(requires (make_total_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) | val make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot t))
: Pure (parser_spec t)
(requires (make_total_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) | let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x)) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 126,
"start_col": 0,
"start_line": 117
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
sz: Prims.nat ->
t: Type0 ->
f: (s: MiniParse.Spec.Base.bytes{FStar.Seq.Base.length s == sz} -> Prims.GTot t)
-> Prims.Pure (MiniParse.Spec.Base.parser_spec t) | Prims.Pure | [] | [] | [
"Prims.nat",
"MiniParse.Spec.Base.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"MiniParse.Spec.Base.byte",
"MiniParse.Spec.Combinators.make_constant_size_parser",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.option",
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Combinators.make_total_constant_size_parser_precond",
"Prims.l_True"
] | [] | false | false | false | false | false | let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot t))
: Pure (parser_spec t)
(requires (make_total_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) =
| make_constant_size_parser sz t (fun x -> Some (f x)) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.make_constant_size_parser | val make_constant_size_parser
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Pure (parser_spec t)
(requires (make_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) | val make_constant_size_parser
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Pure (parser_spec t)
(requires (make_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) | let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 10,
"end_line": 107,
"start_col": 0,
"start_line": 96
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
sz: Prims.nat ->
t: Type0 ->
f:
(s: MiniParse.Spec.Base.bytes{FStar.Seq.Base.length s == sz}
-> Prims.GTot (FStar.Pervasives.Native.option t))
-> Prims.Pure (MiniParse.Spec.Base.parser_spec t) | Prims.Pure | [] | [] | [
"Prims.nat",
"MiniParse.Spec.Base.bytes",
"Prims.eq2",
"FStar.Seq.Base.length",
"MiniParse.Spec.Base.byte",
"FStar.Pervasives.Native.option",
"MiniParse.Spec.Base.Parser",
"Prims.unit",
"MiniParse.Spec.Combinators.make_constant_size_parser_injective",
"MiniParse.Spec.Base.bare_parser",
"MiniParse.Spec.Combinators.make_constant_size_parser_aux",
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Combinators.make_constant_size_parser_precond",
"Prims.l_True"
] | [] | false | false | false | false | false | let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: (s: bytes{Seq.length s == sz} -> GTot (option t)))
: Pure (parser_spec t)
(requires (make_constant_size_parser_precond sz t f))
(ensures (fun _ -> True)) =
| let p:bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.bare_serialize_nondep_then | val bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2)) | val bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2)) | let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 491,
"start_col": 0,
"start_line": 481
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p1: MiniParse.Spec.Base.parser_spec t1 ->
s1: MiniParse.Spec.Base.serializer_spec p1 ->
p2: MiniParse.Spec.Base.parser_spec t2 ->
s2: MiniParse.Spec.Base.serializer_spec p2
-> MiniParse.Spec.Base.bare_serializer (t1 * t2) | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Base.serializer_spec",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Base.append",
"MiniParse.Spec.Base.byte",
"MiniParse.Spec.Base.serialize",
"MiniParse.Spec.Base.bytes",
"MiniParse.Spec.Base.bare_serializer"
] | [] | false | false | false | false | false | let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2)) =
| fun (x: t1 * t2) ->
let x1, x2 = x in
Seq.append (serialize s1 x1) (serialize s2 x2) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.parse_ret' | val parse_ret' (#t: Type) (v: t) : Tot (bare_parser t) | val parse_ret' (#t: Type) (v: t) : Tot (bare_parser t) | let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b)) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 133,
"start_col": 0,
"start_line": 132
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | v: t -> MiniParse.Spec.Base.bare_parser t | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.bytes",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"MiniParse.Spec.Base.consumed_length",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"MiniParse.Spec.Base.bare_parser"
] | [] | false | false | false | true | false | let parse_ret' (#t: Type) (v: t) : Tot (bare_parser t) =
| fun (b: bytes) -> Some (v, (0 <: consumed_length b)) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.serialize_empty | val serialize_empty:serializer_spec parse_empty | val serialize_empty:serializer_spec parse_empty | let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 142,
"start_col": 0,
"start_line": 141
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | MiniParse.Spec.Base.serializer_spec MiniParse.Spec.Combinators.parse_empty | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.Serializer",
"Prims.unit",
"MiniParse.Spec.Combinators.parse_empty",
"FStar.Seq.Base.empty",
"MiniParse.Spec.Base.byte",
"MiniParse.Spec.Base.bytes"
] | [] | false | false | false | true | false | let serialize_empty:serializer_spec parse_empty =
| Serializer (fun _ -> Seq.empty) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.synth_inverse | val synth_inverse (#t1 #t2: Type0) (f2: (t1 -> GTot t2)) (g1: (t2 -> GTot t1)) : GTot Type0 | val synth_inverse (#t1 #t2: Type0) (f2: (t1 -> GTot t2)) (g1: (t2 -> GTot t1)) : GTot Type0 | let synth_inverse
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . f2 (g1 x) == x) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 574,
"start_col": 0,
"start_line": 568
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f2: (_: t1 -> Prims.GTot t2) -> g1: (_: t2 -> Prims.GTot t1) -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.l_Forall",
"Prims.eq2"
] | [] | false | false | false | false | true | let synth_inverse (#t1 #t2: Type0) (f2: (t1 -> GTot t2)) (g1: (t2 -> GTot t1)) : GTot Type0 =
| (forall (x: t2). f2 (g1 x) == x) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.fail_parser | val fail_parser (t: Type0) : Tot (parser_spec t) | val fail_parser (t: Type0) : Tot (parser_spec t) | let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 10,
"end_line": 155,
"start_col": 0,
"start_line": 151
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | t: Type0 -> MiniParse.Spec.Base.parser_spec t | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.Parser",
"MiniParse.Spec.Base.bare_parser",
"MiniParse.Spec.Combinators.fail_parser'",
"MiniParse.Spec.Base.parser_spec"
] | [] | false | false | false | true | false | let fail_parser (t: Type0) : Tot (parser_spec t) =
| let p = fail_parser' t in
Parser p | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.parse_ret | val parse_ret (#t: Type) (v: t) : Tot (parser_spec t) | val parse_ret (#t: Type) (v: t) : Tot (parser_spec t) | let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 136,
"start_col": 0,
"start_line": 135
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | v: t -> MiniParse.Spec.Base.parser_spec t | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.Parser",
"MiniParse.Spec.Combinators.parse_ret'",
"MiniParse.Spec.Base.parser_spec"
] | [] | false | false | false | true | false | let parse_ret (#t: Type) (v: t) : Tot (parser_spec t) =
| Parser (parse_ret' v) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.bare_serialize_synth | val bare_serialize_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) | val bare_serialize_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) | let bare_serialize_synth #t1 #t2 p1 f2 s1 g1 =
fun (x: t2) -> serialize s1 (g1 x) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 625,
"start_col": 0,
"start_line": 624
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v)
let synth_inverse
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . f2 (g1 x) == x)
let parse_synth'
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
: Pure (parser_spec t2)
(requires (
forall (x x' : t1) . f2 x == f2 x' ==> x == x'
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
: Pure (parser_spec t2)
(requires (
synth_inverse g1 f2
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth_eq
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(b: bytes)
: Lemma
(requires (synth_inverse g1 f2))
(ensures (parse (parse_synth p1 f2 g1) b == (match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed))))
= ()
val bare_serialize_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p1: MiniParse.Spec.Base.parser_spec t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
s1: MiniParse.Spec.Base.serializer_spec p1 ->
g1: (_: t2 -> Prims.GTot t1)
-> MiniParse.Spec.Base.bare_serializer t2 | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Base.serializer_spec",
"MiniParse.Spec.Base.serialize",
"MiniParse.Spec.Base.bytes"
] | [] | false | false | false | false | false | let bare_serialize_synth #t1 #t2 p1 f2 s1 g1 =
| fun (x: t2) -> serialize s1 (g1 x) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.and_then_cases_injective_precond | val and_then_cases_injective_precond
(#t #t': Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0 | val and_then_cases_injective_precond
(#t #t': Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0 | let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 264,
"start_col": 0,
"start_line": 252
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p': (_: t -> MiniParse.Spec.Base.bare_parser t') ->
x1: t ->
x2: t ->
b1: MiniParse.Spec.Base.bytes ->
b2: MiniParse.Spec.Base.bytes
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"MiniParse.Spec.Base.bare_parser",
"MiniParse.Spec.Base.bytes",
"Prims.l_and",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Pervasives.Native.tuple2",
"MiniParse.Spec.Base.consumed_length",
"Prims.eq2",
"Prims.logical",
"FStar.Pervasives.Native.option"
] | [] | false | false | false | false | true | let and_then_cases_injective_precond
(#t #t': Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0 =
| Some? ((p' x1) b1) /\ Some? ((p' x2) b2) /\
(let Some (v1, _) = (p' x1) b1 in
let Some (v2, _) = (p' x2) b2 in
v1 == v2) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.and_then_bare | val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t') | val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t') | let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 176,
"start_col": 0,
"start_line": 163
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: MiniParse.Spec.Base.bare_parser t -> p': (_: t -> MiniParse.Spec.Base.bare_parser t')
-> MiniParse.Spec.Base.bare_parser t' | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.bare_parser",
"MiniParse.Spec.Base.bytes",
"MiniParse.Spec.Base.bparse",
"MiniParse.Spec.Base.consumed_length",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Prims.op_Addition",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"FStar.Seq.Base.slice",
"MiniParse.Spec.Base.byte",
"FStar.Seq.Base.length"
] | [] | false | false | false | true | false | let and_then_bare #t #t' p p' =
| fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
let p'v = p' v in
let s':bytes = Seq.slice b l (Seq.length b) in
(match bparse p'v s' with
| Some (v', l') ->
let res:consumed_length b = l + l' in
Some (v', res)
| None -> None)
| None -> None | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.lift_parser' | val lift_parser' (#t: Type0) (f: (unit -> GTot (parser_spec t))) : Tot (bare_parser t) | val lift_parser' (#t: Type0) (f: (unit -> GTot (parser_spec t))) : Tot (bare_parser t) | let lift_parser'
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 677,
"start_col": 0,
"start_line": 673
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v)
let synth_inverse
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . f2 (g1 x) == x)
let parse_synth'
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
: Pure (parser_spec t2)
(requires (
forall (x x' : t1) . f2 x == f2 x' ==> x == x'
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
: Pure (parser_spec t2)
(requires (
synth_inverse g1 f2
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth_eq
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(b: bytes)
: Lemma
(requires (synth_inverse g1 f2))
(ensures (parse (parse_synth p1 f2 g1) b == (match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed))))
= ()
val bare_serialize_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2)
let bare_serialize_synth #t1 #t2 p1 f2 s1 g1 =
fun (x: t2) -> serialize s1 (g1 x)
val bare_serialize_synth_correct
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
synth_inverse g1 f2 /\
synth_inverse f2 g1
))
(ensures (serializer_correct (parse_synth p1 f2 g1) (bare_serialize_synth p1 f2 s1 g1 )))
let bare_serialize_synth_correct #k #t1 p1 f2 s1 g1 =
()
let synth_inverse_intro
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let serialize_synth
(#t1: Type0)
(#t2: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(u: squash (
synth_inverse f2 g1 /\
synth_inverse g1 f2
))
: Tot (serializer_spec (parse_synth p1 f2 g1))
= bare_serialize_synth_correct p1 f2 s1 g1;
Serializer (bare_serialize_synth p1 f2 s1 g1)
(** Tot vs. Ghost *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: (_: Prims.unit -> Prims.GTot (MiniParse.Spec.Base.parser_spec t))
-> MiniParse.Spec.Base.bare_parser t | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Base.bytes",
"MiniParse.Spec.Base.parse",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"MiniParse.Spec.Base.consumed_length",
"MiniParse.Spec.Base.bare_parser"
] | [] | false | false | false | false | false | let lift_parser' (#t: Type0) (f: (unit -> GTot (parser_spec t))) : Tot (bare_parser t) =
| fun (input: bytes) -> parse (f ()) input | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.parse_filter_payload | val parse_filter_payload (#t: Type0) (f: (t -> GTot bool)) (v: t)
: Tot (parser_spec (x: t{f x == true})) | val parse_filter_payload (#t: Type0) (f: (t -> GTot bool)) (v: t)
: Tot (parser_spec (x: t{f x == true})) | let parse_filter_payload
(#t: Type0)
(f: (t -> GTot bool))
(v: t)
: Tot (parser_spec (x: t { f x == true }))
= lift_parser (fun () ->
if f v
then
let v' : (x: t { f x == true } ) = v in
(parse_ret v')
else fail_parser (x: t {f x == true} )
) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 703,
"start_col": 0,
"start_line": 692
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v)
let synth_inverse
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . f2 (g1 x) == x)
let parse_synth'
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
: Pure (parser_spec t2)
(requires (
forall (x x' : t1) . f2 x == f2 x' ==> x == x'
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
: Pure (parser_spec t2)
(requires (
synth_inverse g1 f2
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth_eq
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(b: bytes)
: Lemma
(requires (synth_inverse g1 f2))
(ensures (parse (parse_synth p1 f2 g1) b == (match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed))))
= ()
val bare_serialize_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2)
let bare_serialize_synth #t1 #t2 p1 f2 s1 g1 =
fun (x: t2) -> serialize s1 (g1 x)
val bare_serialize_synth_correct
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
synth_inverse g1 f2 /\
synth_inverse f2 g1
))
(ensures (serializer_correct (parse_synth p1 f2 g1) (bare_serialize_synth p1 f2 s1 g1 )))
let bare_serialize_synth_correct #k #t1 p1 f2 s1 g1 =
()
let synth_inverse_intro
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let serialize_synth
(#t1: Type0)
(#t2: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(u: squash (
synth_inverse f2 g1 /\
synth_inverse g1 f2
))
: Tot (serializer_spec (parse_synth p1 f2 g1))
= bare_serialize_synth_correct p1 f2 s1 g1;
Serializer (bare_serialize_synth p1 f2 s1 g1)
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
unfold
let lift_parser
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (parser_spec t)
= let p = lift_parser' f in
no_lookahead_weak_ext p (coerce_to_bare_parser _ (f ()));
no_lookahead_ext p (coerce_to_bare_parser _ (f ()));
injective_ext p (coerce_to_bare_parser _ (f ()));
Parser p
(** Refinements *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: (_: t -> Prims.GTot Prims.bool) -> v: t -> MiniParse.Spec.Base.parser_spec (x: t{f x == true}) | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"MiniParse.Spec.Combinators.lift_parser",
"Prims.eq2",
"Prims.unit",
"MiniParse.Spec.Combinators.parse_ret",
"MiniParse.Spec.Combinators.fail_parser",
"MiniParse.Spec.Base.parser_spec"
] | [] | false | false | false | false | false | let parse_filter_payload (#t: Type0) (f: (t -> GTot bool)) (v: t)
: Tot (parser_spec (x: t{f x == true})) =
| lift_parser (fun () ->
if f v
then
let v':(x: t{f x == true}) = v in
(parse_ret v')
else fail_parser (x: t{f x == true})) | false |
Hacl.Bignum.Convert.fst | Hacl.Bignum.Convert.mk_bn_to_bytes_be | val mk_bn_to_bytes_be:
#t:limb_t
-> is_known_len:bool
-> len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t} ->
bn_to_bytes_be_st t len | val mk_bn_to_bytes_be:
#t:limb_t
-> is_known_len:bool
-> len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t} ->
bn_to_bytes_be_st t len | let mk_bn_to_bytes_be #t is_known_len len b res =
push_frame ();
if is_known_len then begin
[@inline_let] let numb = size (numbytes t) in
[@inline_let] let bnLen = blocks len numb in
[@inline_let] let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
if tmpLen =. len then begin
LowStar.Ignore.ignore tmp;
bn_to_bytes_be_ bnLen b res end
else begin
HyperStack.ST.break_vc ();
bn_to_bytes_be_ bnLen b tmp;
copy res (sub tmp (tmpLen -! len) len) end end
else begin
[@inline_let] let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
bn_to_bytes_be_ bnLen b tmp;
copy res (sub tmp (tmpLen -! len) len) end;
pop_frame () | {
"file_name": "code/bignum/Hacl.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 213,
"start_col": 0,
"start_line": 192
} | module Hacl.Bignum.Convert
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Bignum.Definitions
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Hacl.Spec.Bignum.Convert
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
val bn_from_uint:
#t:limb_t
-> len:size_t{0 < v len}
-> x:limb t
-> b:lbignum t len ->
Stack unit
(requires fun h -> live h b)
(ensures fun h0 _ h1 -> modifies (loc b) h0 h1 /\
as_seq h1 b == S.bn_from_uint (v len) x)
let bn_from_uint #t len x b =
memset b (uint #t 0) len;
b.(0ul) <- x
inline_for_extraction noextract
val bn_from_bytes_be_:
#t:limb_t
-> len:size_t{numbytes t * v len <= max_size_t}
-> b:lbuffer uint8 (size (numbytes t) *! len)
-> res:lbignum t len ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_from_bytes_be_ (v len) (as_seq h0 b))
let bn_from_bytes_be_ #t len b res =
let h0 = ST.get () in
[@inline_let]
let spec h = S.bn_from_bytes_be_f (v len) (as_seq h b) in
fill h0 len res spec
(fun j -> uint_from_bytes_be (sub b ((len -! j -! 1ul) *! (size (numbytes t))) (size (numbytes t))))
inline_for_extraction noextract
let bn_from_bytes_be_st (t:limb_t) =
len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t}
-> b:lbuffer uint8 len
-> res:lbignum t (blocks len (size (numbytes t))) ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_from_bytes_be (v len) (as_seq h0 b))
inline_for_extraction noextract
val mk_bn_from_bytes_be: #t:limb_t -> is_known_len:bool -> bn_from_bytes_be_st t
let mk_bn_from_bytes_be #t is_known_len len b res =
push_frame ();
if is_known_len then begin
[@inline_let] let numb = size (numbytes t) in
[@inline_let] let bnLen = blocks len numb in
[@inline_let] let tmpLen = numb *! bnLen in
if tmpLen =. len then
bn_from_bytes_be_ bnLen b res
else begin
let tmp = create tmpLen (u8 0) in
update_sub tmp (tmpLen -! len) len b;
bn_from_bytes_be_ bnLen tmp res end end
else begin
[@inline_let] let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
update_sub tmp (tmpLen -! len) len b;
bn_from_bytes_be_ bnLen tmp res end;
pop_frame ()
[@CInline]
let bn_from_bytes_be_uint32 : bn_from_bytes_be_st U32 = mk_bn_from_bytes_be #U32 false
let bn_from_bytes_be_uint64 : bn_from_bytes_be_st U64 = mk_bn_from_bytes_be #U64 false
inline_for_extraction noextract
val bn_from_bytes_be: #t:limb_t -> bn_from_bytes_be_st t
let bn_from_bytes_be #t =
match t with
| U32 -> bn_from_bytes_be_uint32
| U64 -> bn_from_bytes_be_uint64
inline_for_extraction noextract
let bn_from_bytes_le_st (t:limb_t) =
len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t}
-> b:lbuffer uint8 len
-> res:lbignum t (blocks len (size (numbytes t))) ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_from_bytes_le (v len) (as_seq h0 b))
inline_for_extraction noextract
val mk_bn_from_bytes_le: #t:limb_t -> is_known_len:bool -> bn_from_bytes_le_st t
let mk_bn_from_bytes_le #t is_known_len len b res =
push_frame ();
if is_known_len then begin
[@inline_let] let numb = size (numbytes t) in
[@inline_let] let bnLen = blocks len numb in
[@inline_let] let tmpLen = numb *! bnLen in
if tmpLen =. len then
uints_from_bytes_le res b
else begin
let tmp = create tmpLen (u8 0) in
update_sub tmp 0ul len b;
uints_from_bytes_le res tmp end end
else begin
[@inline_let] let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
update_sub tmp 0ul len b;
uints_from_bytes_le res tmp end;
pop_frame ()
[@CInline]
let bn_from_bytes_le_uint32 : bn_from_bytes_le_st U32 = mk_bn_from_bytes_le #U32 false
[@CInline]
let bn_from_bytes_le_uint64 : bn_from_bytes_le_st U64 = mk_bn_from_bytes_le #U64 false
inline_for_extraction noextract
val bn_from_bytes_le: #t:limb_t -> bn_from_bytes_le_st t
let bn_from_bytes_le #t =
match t with
| U32 -> bn_from_bytes_le_uint32
| U64 -> bn_from_bytes_le_uint64
inline_for_extraction noextract
val bn_to_bytes_be_:
#t:limb_t
-> len:size_t{numbytes t * v len <= max_size_t}
-> b:lbignum t len
-> res:lbuffer uint8 (size (numbytes t) *! len) ->
Stack unit
(requires fun h -> live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_to_bytes_be_ (v len) (as_seq h0 b))
let bn_to_bytes_be_ #t len b res =
[@inline_let] let numb = size (numbytes t) in
let h0 = ST.get () in
[@ inline_let]
let a_spec (i:nat{i <= v len}) = unit in
[@ inline_let]
let spec (h:mem) = S.bn_to_bytes_be_f (v len) (as_seq h b) in
fill_blocks h0 numb len res a_spec (fun _ _ -> ()) (fun _ -> LowStar.Buffer.loc_none) spec
(fun j -> uint_to_bytes_be (sub res (j *! numb) numb) b.(len -! j -! 1ul));
norm_spec [delta_only [`%S.bn_to_bytes_be_]] (S.bn_to_bytes_be_ (v len) (as_seq h0 b))
inline_for_extraction noextract
let bn_to_bytes_be_st (t:limb_t) (len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t}) =
b:lbignum t (blocks len (size (numbytes t)))
-> res:lbuffer uint8 len ->
Stack unit
(requires fun h ->
live h b /\ live h res /\ disjoint res b)
(ensures fun h0 _ h1 -> modifies (loc res) h0 h1 /\
as_seq h1 res == S.bn_to_bytes_be (v len) (as_seq h0 b))
inline_for_extraction noextract
val mk_bn_to_bytes_be:
#t:limb_t
-> is_known_len:bool
-> len:size_t{0 < v len /\ numbytes t * v (blocks len (size (numbytes t))) <= max_size_t} ->
bn_to_bytes_be_st t len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Convert.fst.checked",
"Hacl.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.Convert.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Convert",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"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
}
] | {
"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"
} | false |
is_known_len: Prims.bool ->
len:
Lib.IntTypes.size_t
{ 0 < Lib.IntTypes.v len /\
Lib.IntTypes.numbytes t *
Lib.IntTypes.v (Hacl.Bignum.Definitions.blocks len
(Lib.IntTypes.size (Lib.IntTypes.numbytes t))) <=
Lib.IntTypes.max_size_t }
-> Hacl.Bignum.Convert.bn_to_bytes_be_st t len | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Prims.bool",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Bignum.Definitions.blocks",
"Lib.IntTypes.size",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Lib.IntTypes.op_Equals_Dot",
"Hacl.Bignum.Convert.bn_to_bytes_be_",
"LowStar.Ignore.ignore",
"Lib.Buffer.copy",
"Lib.Buffer.MUT",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Buffer.sub",
"Lib.IntTypes.op_Subtraction_Bang",
"FStar.HyperStack.ST.break_vc",
"Lib.Buffer.create",
"Lib.IntTypes.u8",
"Lib.IntTypes.op_Star_Bang",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.op_GreaterThan",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Definitions.blocks",
"FStar.HyperStack.ST.push_frame"
] | [] | false | false | false | false | false | let mk_bn_to_bytes_be #t is_known_len len b res =
| push_frame ();
if is_known_len
then
[@@ inline_let ]let numb = size (numbytes t) in
[@@ inline_let ]let bnLen = blocks len numb in
[@@ inline_let ]let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
if tmpLen =. len
then
(LowStar.Ignore.ignore tmp;
bn_to_bytes_be_ bnLen b res)
else
(HyperStack.ST.break_vc ();
bn_to_bytes_be_ bnLen b tmp;
copy res (sub tmp (tmpLen -! len) len))
else
([@@ inline_let ]let numb = size (numbytes t) in
let bnLen = blocks len numb in
let tmpLen = numb *! bnLen in
let tmp = create tmpLen (u8 0) in
bn_to_bytes_be_ bnLen b tmp;
copy res (sub tmp (tmpLen -! len) len));
pop_frame () | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.serialize_filter' | val serialize_filter' (#t: Type0) (#p: parser_spec t) (s: serializer_spec p) (f: (t -> GTot bool))
: Tot (bare_serializer (x: t{f x == true})) | val serialize_filter' (#t: Type0) (#p: parser_spec t) (s: serializer_spec p) (f: (t -> GTot bool))
: Tot (bare_serializer (x: t{f x == true})) | let serialize_filter'
(#t: Type0)
(#p: parser_spec t)
(s: serializer_spec p)
(f: (t -> GTot bool))
: Tot (bare_serializer (x: t { f x == true } ))
= fun (input: t { f input == true } ) -> serialize s input | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 58,
"end_line": 718,
"start_col": 0,
"start_line": 712
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v)
let synth_inverse
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . f2 (g1 x) == x)
let parse_synth'
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
: Pure (parser_spec t2)
(requires (
forall (x x' : t1) . f2 x == f2 x' ==> x == x'
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
: Pure (parser_spec t2)
(requires (
synth_inverse g1 f2
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth_eq
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(b: bytes)
: Lemma
(requires (synth_inverse g1 f2))
(ensures (parse (parse_synth p1 f2 g1) b == (match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed))))
= ()
val bare_serialize_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2)
let bare_serialize_synth #t1 #t2 p1 f2 s1 g1 =
fun (x: t2) -> serialize s1 (g1 x)
val bare_serialize_synth_correct
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
synth_inverse g1 f2 /\
synth_inverse f2 g1
))
(ensures (serializer_correct (parse_synth p1 f2 g1) (bare_serialize_synth p1 f2 s1 g1 )))
let bare_serialize_synth_correct #k #t1 p1 f2 s1 g1 =
()
let synth_inverse_intro
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let serialize_synth
(#t1: Type0)
(#t2: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(u: squash (
synth_inverse f2 g1 /\
synth_inverse g1 f2
))
: Tot (serializer_spec (parse_synth p1 f2 g1))
= bare_serialize_synth_correct p1 f2 s1 g1;
Serializer (bare_serialize_synth p1 f2 s1 g1)
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
unfold
let lift_parser
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (parser_spec t)
= let p = lift_parser' f in
no_lookahead_weak_ext p (coerce_to_bare_parser _ (f ()));
no_lookahead_ext p (coerce_to_bare_parser _ (f ()));
injective_ext p (coerce_to_bare_parser _ (f ()));
Parser p
(** Refinements *)
let parse_filter_payload
(#t: Type0)
(f: (t -> GTot bool))
(v: t)
: Tot (parser_spec (x: t { f x == true }))
= lift_parser (fun () ->
if f v
then
let v' : (x: t { f x == true } ) = v in
(parse_ret v')
else fail_parser (x: t {f x == true} )
)
let parse_filter
(#t: Type0)
(p: parser_spec t)
(f: (t -> GTot bool))
: Tot (parser_spec (x: t { f x == true }))
= p `and_then` (parse_filter_payload f) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: MiniParse.Spec.Base.serializer_spec p -> f: (_: t -> Prims.GTot Prims.bool)
-> MiniParse.Spec.Base.bare_serializer (x: t{f x == true}) | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Base.serializer_spec",
"Prims.bool",
"Prims.eq2",
"MiniParse.Spec.Base.serialize",
"MiniParse.Spec.Base.bytes",
"MiniParse.Spec.Base.bare_serializer"
] | [] | false | false | false | false | false | let serialize_filter' (#t: Type0) (#p: parser_spec t) (s: serializer_spec p) (f: (t -> GTot bool))
: Tot (bare_serializer (x: t{f x == true})) =
| fun (input: t{f input == true}) -> serialize s input | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.cond_true | val cond_true (cond: bool) : Tot Type0 | val cond_true (cond: bool) : Tot Type0 | let cond_true (cond: bool) : Tot Type0 = squash (cond == true) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 730,
"start_col": 0,
"start_line": 730
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v)
let synth_inverse
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . f2 (g1 x) == x)
let parse_synth'
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
: Pure (parser_spec t2)
(requires (
forall (x x' : t1) . f2 x == f2 x' ==> x == x'
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
: Pure (parser_spec t2)
(requires (
synth_inverse g1 f2
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth_eq
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(b: bytes)
: Lemma
(requires (synth_inverse g1 f2))
(ensures (parse (parse_synth p1 f2 g1) b == (match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed))))
= ()
val bare_serialize_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2)
let bare_serialize_synth #t1 #t2 p1 f2 s1 g1 =
fun (x: t2) -> serialize s1 (g1 x)
val bare_serialize_synth_correct
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
synth_inverse g1 f2 /\
synth_inverse f2 g1
))
(ensures (serializer_correct (parse_synth p1 f2 g1) (bare_serialize_synth p1 f2 s1 g1 )))
let bare_serialize_synth_correct #k #t1 p1 f2 s1 g1 =
()
let synth_inverse_intro
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let serialize_synth
(#t1: Type0)
(#t2: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(u: squash (
synth_inverse f2 g1 /\
synth_inverse g1 f2
))
: Tot (serializer_spec (parse_synth p1 f2 g1))
= bare_serialize_synth_correct p1 f2 s1 g1;
Serializer (bare_serialize_synth p1 f2 s1 g1)
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
unfold
let lift_parser
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (parser_spec t)
= let p = lift_parser' f in
no_lookahead_weak_ext p (coerce_to_bare_parser _ (f ()));
no_lookahead_ext p (coerce_to_bare_parser _ (f ()));
injective_ext p (coerce_to_bare_parser _ (f ()));
Parser p
(** Refinements *)
let parse_filter_payload
(#t: Type0)
(f: (t -> GTot bool))
(v: t)
: Tot (parser_spec (x: t { f x == true }))
= lift_parser (fun () ->
if f v
then
let v' : (x: t { f x == true } ) = v in
(parse_ret v')
else fail_parser (x: t {f x == true} )
)
let parse_filter
(#t: Type0)
(p: parser_spec t)
(f: (t -> GTot bool))
: Tot (parser_spec (x: t { f x == true }))
= p `and_then` (parse_filter_payload f)
let serialize_filter'
(#t: Type0)
(#p: parser_spec t)
(s: serializer_spec p)
(f: (t -> GTot bool))
: Tot (bare_serializer (x: t { f x == true } ))
= fun (input: t { f input == true } ) -> serialize s input
let serialize_filter
(#t: Type0)
(#p: parser_spec t)
(s: serializer_spec p)
(f: (t -> GTot bool))
: Tot (serializer_spec (parse_filter p f))
= Serializer (serialize_filter' s f)
(* Helpers to define `if` combinators *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | cond: Prims.bool -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Prims.squash",
"Prims.eq2"
] | [] | false | false | false | true | true | let cond_true (cond: bool) : Tot Type0 =
| squash (cond == true) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.cond_false | val cond_false (cond: bool) : Tot Type0 | val cond_false (cond: bool) : Tot Type0 | let cond_false (cond: bool) : Tot Type0 = squash (cond == false) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 64,
"end_line": 732,
"start_col": 0,
"start_line": 732
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v)
let synth_inverse
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . f2 (g1 x) == x)
let parse_synth'
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
: Pure (parser_spec t2)
(requires (
forall (x x' : t1) . f2 x == f2 x' ==> x == x'
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
: Pure (parser_spec t2)
(requires (
synth_inverse g1 f2
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth_eq
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(b: bytes)
: Lemma
(requires (synth_inverse g1 f2))
(ensures (parse (parse_synth p1 f2 g1) b == (match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed))))
= ()
val bare_serialize_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2)
let bare_serialize_synth #t1 #t2 p1 f2 s1 g1 =
fun (x: t2) -> serialize s1 (g1 x)
val bare_serialize_synth_correct
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
synth_inverse g1 f2 /\
synth_inverse f2 g1
))
(ensures (serializer_correct (parse_synth p1 f2 g1) (bare_serialize_synth p1 f2 s1 g1 )))
let bare_serialize_synth_correct #k #t1 p1 f2 s1 g1 =
()
let synth_inverse_intro
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let serialize_synth
(#t1: Type0)
(#t2: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(u: squash (
synth_inverse f2 g1 /\
synth_inverse g1 f2
))
: Tot (serializer_spec (parse_synth p1 f2 g1))
= bare_serialize_synth_correct p1 f2 s1 g1;
Serializer (bare_serialize_synth p1 f2 s1 g1)
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
unfold
let lift_parser
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (parser_spec t)
= let p = lift_parser' f in
no_lookahead_weak_ext p (coerce_to_bare_parser _ (f ()));
no_lookahead_ext p (coerce_to_bare_parser _ (f ()));
injective_ext p (coerce_to_bare_parser _ (f ()));
Parser p
(** Refinements *)
let parse_filter_payload
(#t: Type0)
(f: (t -> GTot bool))
(v: t)
: Tot (parser_spec (x: t { f x == true }))
= lift_parser (fun () ->
if f v
then
let v' : (x: t { f x == true } ) = v in
(parse_ret v')
else fail_parser (x: t {f x == true} )
)
let parse_filter
(#t: Type0)
(p: parser_spec t)
(f: (t -> GTot bool))
: Tot (parser_spec (x: t { f x == true }))
= p `and_then` (parse_filter_payload f)
let serialize_filter'
(#t: Type0)
(#p: parser_spec t)
(s: serializer_spec p)
(f: (t -> GTot bool))
: Tot (bare_serializer (x: t { f x == true } ))
= fun (input: t { f input == true } ) -> serialize s input
let serialize_filter
(#t: Type0)
(#p: parser_spec t)
(s: serializer_spec p)
(f: (t -> GTot bool))
: Tot (serializer_spec (parse_filter p f))
= Serializer (serialize_filter' s f)
(* Helpers to define `if` combinators *)
let cond_true (cond: bool) : Tot Type0 = squash (cond == true) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | cond: Prims.bool -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Prims.squash",
"Prims.eq2"
] | [] | false | false | false | true | true | let cond_false (cond: bool) : Tot Type0 =
| squash (cond == false) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.and_then_no_lookahead | val and_then_no_lookahead
(#t: Type)
(p: parser_spec t)
(#t': Type)
(p': (t -> Tot (parser_spec t')))
: Lemma (requires (and_then_cases_injective p'))
(ensures
(no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')))) | val and_then_no_lookahead
(#t: Type)
(p: parser_spec t)
(#t': Type)
(p': (t -> Tot (parser_spec t')))
: Lemma (requires (and_then_cases_injective p'))
(ensures
(no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')))) | let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x)) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 151,
"end_line": 410,
"start_col": 0,
"start_line": 400
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: MiniParse.Spec.Base.parser_spec t -> p': (_: t -> MiniParse.Spec.Base.parser_spec t')
-> FStar.Pervasives.Lemma (requires MiniParse.Spec.Combinators.and_then_cases_injective p')
(ensures
MiniParse.Spec.Base.no_lookahead (MiniParse.Spec.Combinators.and_then_bare (MiniParse.Spec.Base.coerce_to_bare_parser
t
p)
(MiniParse.Spec.Combinators.coerce_to_bare_param_parser p'))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"MiniParse.Spec.Base.parser_spec",
"FStar.Classical.forall_intro_2",
"MiniParse.Spec.Base.bytes",
"Prims.l_imp",
"Prims.l_and",
"MiniParse.Spec.Base.no_lookahead",
"MiniParse.Spec.Base.coerce_to_bare_parser",
"MiniParse.Spec.Base.injective",
"Prims.l_Forall",
"MiniParse.Spec.Combinators.coerce_to_bare_param_parser",
"MiniParse.Spec.Base.no_lookahead_on",
"MiniParse.Spec.Combinators.and_then_bare",
"FStar.Classical.move_requires",
"MiniParse.Spec.Combinators.and_then_no_lookahead_on",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"MiniParse.Spec.Combinators.and_then_cases_injective"
] | [] | false | false | true | false | false | let and_then_no_lookahead
(#t: Type)
(p: parser_spec t)
(#t': Type)
(p': (t -> Tot (parser_spec t')))
: Lemma (requires (and_then_cases_injective p'))
(ensures
(no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')))) =
| Classical.forall_intro_2 (fun x ->
Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p)
(coerce_to_bare_param_parser p')
x)) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.and_then_no_lookahead_weak | val and_then_no_lookahead_weak (#t #t': Type) (p: bare_parser t) (p': (t -> Tot (bare_parser t')))
: Lemma (requires (no_lookahead_weak p /\ (forall (x: t). no_lookahead_weak (p' x))))
(ensures (no_lookahead_weak (and_then_bare p p'))) | val and_then_no_lookahead_weak (#t #t': Type) (p: bare_parser t) (p': (t -> Tot (bare_parser t')))
: Lemma (requires (no_lookahead_weak p /\ (forall (x: t). no_lookahead_weak (p' x))))
(ensures (no_lookahead_weak (and_then_bare p p'))) | let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x)) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 100,
"end_line": 250,
"start_col": 0,
"start_line": 239
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: MiniParse.Spec.Base.bare_parser t -> p': (_: t -> MiniParse.Spec.Base.bare_parser t')
-> FStar.Pervasives.Lemma
(requires
MiniParse.Spec.Base.no_lookahead_weak p /\
(forall (x: t). MiniParse.Spec.Base.no_lookahead_weak (p' x)))
(ensures MiniParse.Spec.Base.no_lookahead_weak (MiniParse.Spec.Combinators.and_then_bare p p')
) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"MiniParse.Spec.Base.bare_parser",
"FStar.Classical.forall_intro_2",
"MiniParse.Spec.Base.bytes",
"Prims.l_imp",
"Prims.l_and",
"MiniParse.Spec.Base.no_lookahead_weak",
"Prims.l_Forall",
"MiniParse.Spec.Base.no_lookahead_weak_on",
"MiniParse.Spec.Combinators.and_then_bare",
"FStar.Classical.move_requires",
"MiniParse.Spec.Combinators.and_then_no_lookahead_weak_on",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let and_then_no_lookahead_weak (#t #t': Type) (p: bare_parser t) (p': (t -> Tot (bare_parser t')))
: Lemma (requires (no_lookahead_weak p /\ (forall (x: t). no_lookahead_weak (p' x))))
(ensures (no_lookahead_weak (and_then_bare p p'))) =
| Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x)) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.parse_fret | val parse_fret (#t #t': Type) (f: (t -> GTot t')) (v: t) : Tot (parser_spec t') | val parse_fret (#t #t': Type) (f: (t -> GTot t')) (v: t) : Tot (parser_spec t') | let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 566,
"start_col": 0,
"start_line": 565
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: (_: t -> Prims.GTot t') -> v: t -> MiniParse.Spec.Base.parser_spec t' | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.Parser",
"MiniParse.Spec.Combinators.parse_fret'",
"MiniParse.Spec.Base.parser_spec"
] | [] | false | false | false | false | false | let parse_fret (#t #t': Type) (f: (t -> GTot t')) (v: t) : Tot (parser_spec t') =
| Parser (parse_fret' f v) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.and_then | val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True)) | val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True)) | let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 10,
"end_line": 448,
"start_col": 0,
"start_line": 445
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | p: MiniParse.Spec.Base.parser_spec t -> p': (_: t -> MiniParse.Spec.Base.parser_spec t')
-> Prims.Pure (MiniParse.Spec.Base.parser_spec t') | Prims.Pure | [] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Base.Parser",
"Prims.unit",
"MiniParse.Spec.Combinators.and_then_correct",
"MiniParse.Spec.Base.bare_parser",
"MiniParse.Spec.Combinators.and_then_bare",
"MiniParse.Spec.Base.coerce_to_bare_parser",
"MiniParse.Spec.Combinators.coerce_to_bare_param_parser"
] | [] | false | false | false | false | false | let and_then #t p #t' p' =
| let f:bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p';
Parser f | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.nondep_then | val nondep_then (#t1: Type0) (p1: parser_spec t1) (#t2: Type0) (p2: parser_spec t2)
: Tot (parser_spec (t1 * t2)) | val nondep_then (#t1: Type0) (p1: parser_spec t1) (#t2: Type0) (p2: parser_spec t2)
: Tot (parser_spec (t1 * t2)) | let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2)))) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 74,
"end_line": 460,
"start_col": 0,
"start_line": 454
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p1: MiniParse.Spec.Base.parser_spec t1 -> p2: MiniParse.Spec.Base.parser_spec t2
-> MiniParse.Spec.Base.parser_spec (t1 * t2) | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Combinators.and_then",
"FStar.Pervasives.Native.tuple2",
"MiniParse.Spec.Combinators.parse_ret",
"FStar.Pervasives.Native.Mktuple2"
] | [] | false | false | false | true | false | let nondep_then (#t1: Type0) (p1: parser_spec t1) (#t2: Type0) (p2: parser_spec t2)
: Tot (parser_spec (t1 * t2)) =
| p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2)))) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.and_then_correct | val and_then_correct (#t: Type) (p: parser_spec t) (#t': Type) (p': (t -> Tot (parser_spec t')))
: Lemma (requires (and_then_cases_injective p'))
(ensures
(no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p)
(coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')))
) | val and_then_correct (#t: Type) (p: parser_spec t) (#t': Type) (p': (t -> Tot (parser_spec t')))
: Lemma (requires (and_then_cases_injective p'))
(ensures
(no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p)
(coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')))
) | let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p' | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 430,
"start_col": 0,
"start_line": 414
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 8,
"no_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": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: MiniParse.Spec.Base.parser_spec t -> p': (_: t -> MiniParse.Spec.Base.parser_spec t')
-> FStar.Pervasives.Lemma (requires MiniParse.Spec.Combinators.and_then_cases_injective p')
(ensures
MiniParse.Spec.Base.no_lookahead_weak (MiniParse.Spec.Combinators.and_then_bare (MiniParse.Spec.Base.coerce_to_bare_parser
t
p)
(MiniParse.Spec.Combinators.coerce_to_bare_param_parser p')) /\
MiniParse.Spec.Base.injective (MiniParse.Spec.Combinators.and_then_bare (MiniParse.Spec.Base.coerce_to_bare_parser
t
p)
(MiniParse.Spec.Combinators.coerce_to_bare_param_parser p')) /\
MiniParse.Spec.Base.no_lookahead (MiniParse.Spec.Combinators.and_then_bare (MiniParse.Spec.Base.coerce_to_bare_parser
t
p)
(MiniParse.Spec.Combinators.coerce_to_bare_param_parser p'))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Combinators.and_then_no_lookahead",
"Prims.unit",
"MiniParse.Spec.Combinators.and_then_injective",
"MiniParse.Spec.Base.coerce_to_bare_parser",
"MiniParse.Spec.Combinators.coerce_to_bare_param_parser",
"MiniParse.Spec.Combinators.and_then_no_lookahead_weak",
"MiniParse.Spec.Combinators.and_then_cases_injective",
"Prims.squash",
"Prims.l_and",
"MiniParse.Spec.Base.no_lookahead_weak",
"MiniParse.Spec.Combinators.and_then_bare",
"MiniParse.Spec.Base.injective",
"MiniParse.Spec.Base.no_lookahead",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let and_then_correct (#t: Type) (p: parser_spec t) (#t': Type) (p': (t -> Tot (parser_spec t')))
: Lemma (requires (and_then_cases_injective p'))
(ensures
(no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p)
(coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')))
) =
| and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p' | false |
FStar.Matrix.fst | FStar.Matrix.foldm | val foldm : (#c:Type) -> (#eq:CE.equiv c) -> (#m:pos) -> (#n:pos) -> (cm: CE.cm c eq) -> (mx:matrix c m n) -> c | val foldm : (#c:Type) -> (#eq:CE.equiv c) -> (#m:pos) -> (#n:pos) -> (cm: CE.cm c eq) -> (mx:matrix c m n) -> c | let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 64,
"start_col": 0,
"start_line": 64
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | cm: FStar.Algebra.CommMonoid.Equiv.cm c eq -> mx: FStar.Matrix.matrix c m n -> c | Prims.Tot | [
"total"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix",
"FStar.Seq.Permutation.foldm_snoc"
] | [] | false | false | false | false | false | let foldm #c #eq #m #n cm mx =
| SP.foldm_snoc cm mx | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.seq_slice_append_l | val seq_slice_append_l (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1) | val seq_slice_append_l (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1) | let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 72,
"end_line": 498,
"start_col": 0,
"start_line": 493
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s1: FStar.Seq.Base.seq t -> s2: FStar.Seq.Base.seq t
-> FStar.Pervasives.Lemma
(ensures FStar.Seq.Base.slice (FStar.Seq.Base.append s1 s2) 0 (FStar.Seq.Base.length s1) == s1) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.append",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let seq_slice_append_l (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1) =
| assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_of_seq | val matrix_of_seq : (#c: Type) -> (m:pos) -> (n:pos) -> (s: SB.seq c{SB.length s = m*n}) -> matrix c m n | val matrix_of_seq : (#c: Type) -> (m:pos) -> (n:pos) -> (s: SB.seq c{SB.length s = m*n}) -> matrix c m n | let matrix_of_seq #c m n s = s | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 62,
"start_col": 0,
"start_line": 62
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | m: Prims.pos -> n: Prims.pos -> s: FStar.Seq.Base.seq c {FStar.Seq.Base.length s = m * n}
-> FStar.Matrix.matrix c m n | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Mul.op_Star",
"FStar.Matrix.matrix"
] | [] | false | false | false | false | false | let matrix_of_seq #c m n s =
| s | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.seq_slice_append_r | val seq_slice_append_r (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2) | val seq_slice_append_r (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2) | let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 102,
"end_line": 505,
"start_col": 0,
"start_line": 500
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s1: FStar.Seq.Base.seq t -> s2: FStar.Seq.Base.seq t
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (FStar.Seq.Base.append s1 s2)
(FStar.Seq.Base.length s1)
(FStar.Seq.Base.length (FStar.Seq.Base.append s1 s2)) ==
s2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.append",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let seq_slice_append_r (#t: Type) (s1 s2: Seq.seq t)
: Lemma (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2) =
| assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.and_then_injective | val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
)) | val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
)) | let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x)) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 67,
"end_line": 332,
"start_col": 0,
"start_line": 305
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: MiniParse.Spec.Base.bare_parser t -> p': (_: t -> MiniParse.Spec.Base.bare_parser t')
-> FStar.Pervasives.Lemma
(requires
MiniParse.Spec.Base.injective p /\ (forall (x: t). MiniParse.Spec.Base.injective (p' x)) /\
MiniParse.Spec.Combinators.and_then_cases_injective' p')
(ensures MiniParse.Spec.Base.injective (MiniParse.Spec.Combinators.and_then_bare p p')) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"MiniParse.Spec.Base.bare_parser",
"FStar.Classical.forall_intro_2",
"MiniParse.Spec.Base.bytes",
"Prims.l_imp",
"MiniParse.Spec.Base.injective_precond",
"MiniParse.Spec.Base.injective_postcond",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"MiniParse.Spec.Base.consumed_length",
"Prims._assert",
"FStar.Seq.Properties.lemma_split",
"MiniParse.Spec.Base.byte",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.eq2",
"Prims.nat",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"MiniParse.Spec.Base.injective",
"MiniParse.Spec.Combinators.and_then_cases_injective_precond",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Seq.Base.length",
"MiniParse.Spec.Combinators.and_then_bare"
] | [] | false | false | true | false | false | let and_then_injective #t #t' p p' =
| let ps = and_then_bare p p' in
let f (b1 b2: bytes)
: Lemma (requires (injective_precond ps b1 b2)) (ensures (injective_postcond ps b1 b2)) =
let Some (v1, len1) = p b1 in
let Some (v2, len2) = p b2 in
let b1':bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2':bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let Some (_, len1') = (p' v1) b1' in
let Some (_, len2') = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x)) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.and_then_no_lookahead_weak_on | val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x')) | val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x')) | let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> () | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 237,
"start_col": 0,
"start_line": 192
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x')) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p: MiniParse.Spec.Base.bare_parser t ->
p': (_: t -> MiniParse.Spec.Base.bare_parser t') ->
x: MiniParse.Spec.Base.bytes ->
x': MiniParse.Spec.Base.bytes
-> FStar.Pervasives.Lemma
(requires
MiniParse.Spec.Base.no_lookahead_weak p /\
(forall (x: t). MiniParse.Spec.Base.no_lookahead_weak (p' x)))
(ensures
MiniParse.Spec.Base.no_lookahead_weak_on (MiniParse.Spec.Combinators.and_then_bare p p')
x
x') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"MiniParse.Spec.Base.bare_parser",
"MiniParse.Spec.Base.bytes",
"FStar.Pervasives.Native.tuple2",
"MiniParse.Spec.Base.consumed_length",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"MiniParse.Spec.Base.byte",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.eq2",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"FStar.Pervasives.Native.uu___is_Some",
"MiniParse.Spec.Base.bparse",
"Prims.nat",
"Prims.logical",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims._assert",
"MiniParse.Spec.Base.no_lookahead_weak_on",
"Prims.op_Addition",
"Prims.int",
"FStar.Pervasives.Native.option",
"Prims.bool",
"MiniParse.Spec.Combinators.and_then_bare"
] | [] | false | false | true | false | false | let and_then_no_lookahead_weak_on #t #t' p p' x x' =
| let f = and_then_bare p p' in
match f x with
| Some v ->
let y, off = v in
let off:nat = off in
let off_x:consumed_length x = off in
if off <= Seq.length x'
then
let off_x':consumed_length x' = off in
let g ()
: Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures
(Some? (bparse f x') /\
(let Some v' = bparse f x' in
let y', off' = v' in
y == y' /\ (off <: nat) == (off' <: nat)))) =
assert (Some? (bparse p x));
let Some (y1, off1) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let Some v1' = bparse p x' in
let y1', off1' = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2:bytes = Seq.slice x off1 (Seq.length x) in
let x2':bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let Some (y', off2) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
| _ -> () | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.serialize_nondep_then | val serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2)) | val serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2)) | let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 556,
"start_col": 0,
"start_line": 547
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s1: MiniParse.Spec.Base.serializer_spec p1 -> s2: MiniParse.Spec.Base.serializer_spec p2
-> MiniParse.Spec.Base.serializer_spec (MiniParse.Spec.Combinators.nondep_then p1 p2) | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Base.serializer_spec",
"MiniParse.Spec.Base.Serializer",
"FStar.Pervasives.Native.tuple2",
"MiniParse.Spec.Combinators.nondep_then",
"MiniParse.Spec.Combinators.bare_serialize_nondep_then",
"Prims.unit",
"MiniParse.Spec.Combinators.bare_serialize_nondep_then_correct"
] | [] | false | false | false | false | false | let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2)) =
| bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.lift_parser | val lift_parser (#t: Type0) (f: (unit -> GTot (parser_spec t))) : Tot (parser_spec t) | val lift_parser (#t: Type0) (f: (unit -> GTot (parser_spec t))) : Tot (parser_spec t) | let lift_parser
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (parser_spec t)
= let p = lift_parser' f in
no_lookahead_weak_ext p (coerce_to_bare_parser _ (f ()));
no_lookahead_ext p (coerce_to_bare_parser _ (f ()));
injective_ext p (coerce_to_bare_parser _ (f ()));
Parser p | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 10,
"end_line": 688,
"start_col": 0,
"start_line": 680
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v)
let synth_inverse
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . f2 (g1 x) == x)
let parse_synth'
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
: Pure (parser_spec t2)
(requires (
forall (x x' : t1) . f2 x == f2 x' ==> x == x'
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
: Pure (parser_spec t2)
(requires (
synth_inverse g1 f2
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth_eq
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(b: bytes)
: Lemma
(requires (synth_inverse g1 f2))
(ensures (parse (parse_synth p1 f2 g1) b == (match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed))))
= ()
val bare_serialize_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2)
let bare_serialize_synth #t1 #t2 p1 f2 s1 g1 =
fun (x: t2) -> serialize s1 (g1 x)
val bare_serialize_synth_correct
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
synth_inverse g1 f2 /\
synth_inverse f2 g1
))
(ensures (serializer_correct (parse_synth p1 f2 g1) (bare_serialize_synth p1 f2 s1 g1 )))
let bare_serialize_synth_correct #k #t1 p1 f2 s1 g1 =
()
let synth_inverse_intro
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let serialize_synth
(#t1: Type0)
(#t2: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(u: squash (
synth_inverse f2 g1 /\
synth_inverse g1 f2
))
: Tot (serializer_spec (parse_synth p1 f2 g1))
= bare_serialize_synth_correct p1 f2 s1 g1;
Serializer (bare_serialize_synth p1 f2 s1 g1)
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: (_: Prims.unit -> Prims.GTot (MiniParse.Spec.Base.parser_spec t))
-> MiniParse.Spec.Base.parser_spec t | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Base.Parser",
"MiniParse.Spec.Base.injective_ext",
"MiniParse.Spec.Base.coerce_to_bare_parser",
"MiniParse.Spec.Base.no_lookahead_ext",
"MiniParse.Spec.Base.no_lookahead_weak_ext",
"MiniParse.Spec.Base.bare_parser",
"MiniParse.Spec.Combinators.lift_parser'"
] | [] | false | false | false | false | false | let lift_parser (#t: Type0) (f: (unit -> GTot (parser_spec t))) : Tot (parser_spec t) =
| let p = lift_parser' f in
no_lookahead_weak_ext p (coerce_to_bare_parser _ (f ()));
no_lookahead_ext p (coerce_to_bare_parser _ (f ()));
injective_ext p (coerce_to_bare_parser _ (f ()));
Parser p | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.and_then_no_lookahead_on | val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x')) | val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x')) | let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> () | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 398,
"start_col": 0,
"start_line": 349
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x')) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p: MiniParse.Spec.Base.bare_parser t ->
p': (_: t -> MiniParse.Spec.Base.bare_parser t') ->
x: MiniParse.Spec.Base.bytes ->
x': MiniParse.Spec.Base.bytes
-> FStar.Pervasives.Lemma
(requires
MiniParse.Spec.Base.no_lookahead p /\ MiniParse.Spec.Base.injective p /\
(forall (x: t). MiniParse.Spec.Base.no_lookahead (p' x)))
(ensures
MiniParse.Spec.Base.no_lookahead_on (MiniParse.Spec.Combinators.and_then_bare p p') x x') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"MiniParse.Spec.Base.bare_parser",
"MiniParse.Spec.Base.bytes",
"FStar.Pervasives.Native.tuple2",
"MiniParse.Spec.Base.consumed_length",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"MiniParse.Spec.Base.byte",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.eq2",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"Prims.l_and",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.logical",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims._assert",
"FStar.Pervasives.Native.option",
"MiniParse.Spec.Base.no_lookahead_on",
"Prims.op_Addition",
"Prims.int",
"Prims.nat",
"MiniParse.Spec.Base.injective_precond",
"Prims.bool",
"MiniParse.Spec.Combinators.and_then_bare"
] | [] | false | false | true | false | false | let and_then_no_lookahead_on #t #t' p p' x x' =
| let f = and_then_bare p p' in
match f x with
| Some v ->
let y, off = v in
let off:nat = off in
let off_x:consumed_length x = off in
if off <= Seq.length x'
then
let off_x':consumed_length x' = off in
let g ()
: Lemma (requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures
(Some? (f x') /\
(let Some v' = f x' in
let y', off' = v' in
y == y'))) =
assert (Some? (p x));
let Some (y1, off1) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let Some v1' = p x' in
let y1', off1' = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2:bytes = Seq.slice x off1 (Seq.length x) in
let x2':bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let Some (y2, off2) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let Some v2' = p2 x2' in
let y2', _ = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
| _ -> () | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.parse_synth | val parse_synth (#t1 #t2: Type0) (p1: parser_spec t1) (f2: (t1 -> GTot t2)) (g1: (t2 -> GTot t1))
: Pure (parser_spec t2) (requires (synth_inverse g1 f2)) (ensures (fun _ -> True)) | val parse_synth (#t1 #t2: Type0) (p1: parser_spec t1) (f2: (t1 -> GTot t2)) (g1: (t2 -> GTot t1))
: Pure (parser_spec t2) (requires (synth_inverse g1 f2)) (ensures (fun _ -> True)) | let parse_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
: Pure (parser_spec t2)
(requires (
synth_inverse g1 f2
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1)) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 599,
"start_col": 0,
"start_line": 588
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v)
let synth_inverse
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . f2 (g1 x) == x)
let parse_synth'
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
: Pure (parser_spec t2)
(requires (
forall (x x' : t1) . f2 x == f2 x' ==> x == x'
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p1: MiniParse.Spec.Base.parser_spec t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
g1: (_: t2 -> Prims.GTot t1)
-> Prims.Pure (MiniParse.Spec.Base.parser_spec t2) | Prims.Pure | [] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Combinators.and_then",
"MiniParse.Spec.Combinators.parse_fret",
"MiniParse.Spec.Combinators.synth_inverse",
"Prims.l_True"
] | [] | false | false | false | false | false | let parse_synth (#t1 #t2: Type0) (p1: parser_spec t1) (f2: (t1 -> GTot t2)) (g1: (t2 -> GTot t1))
: Pure (parser_spec t2) (requires (synth_inverse g1 f2)) (ensures (fun _ -> True)) =
| (and_then p1 (fun v1 -> parse_fret f2 v1)) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.parse_fret' | val parse_fret' (#t #t': Type) (f: (t -> GTot t')) (v: t) : Tot (bare_parser t') | val parse_fret' (#t #t': Type) (f: (t -> GTot t')) (v: t) : Tot (bare_parser t') | let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b)) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 562,
"start_col": 0,
"start_line": 561
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: (_: t -> Prims.GTot t') -> v: t -> MiniParse.Spec.Base.bare_parser t' | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.bytes",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"MiniParse.Spec.Base.consumed_length",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"MiniParse.Spec.Base.bare_parser"
] | [] | false | false | false | false | false | let parse_fret' (#t #t': Type) (f: (t -> GTot t')) (v: t) : Tot (bare_parser t') =
| fun (b: bytes) -> Some (f v, (0 <: consumed_length b)) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.parse_synth' | val parse_synth' (#t1 #t2: Type0) (p1: parser_spec t1) (f2: (t1 -> GTot t2))
: Pure (parser_spec t2)
(requires (forall (x: t1) (x': t1). f2 x == f2 x' ==> x == x'))
(ensures (fun _ -> True)) | val parse_synth' (#t1 #t2: Type0) (p1: parser_spec t1) (f2: (t1 -> GTot t2))
: Pure (parser_spec t2)
(requires (forall (x: t1) (x': t1). f2 x == f2 x' ==> x == x'))
(ensures (fun _ -> True)) | let parse_synth'
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
: Pure (parser_spec t2)
(requires (
forall (x x' : t1) . f2 x == f2 x' ==> x == x'
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1)) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 586,
"start_col": 0,
"start_line": 576
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v)
let synth_inverse
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . f2 (g1 x) == x) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p1: MiniParse.Spec.Base.parser_spec t1 -> f2: (_: t1 -> Prims.GTot t2)
-> Prims.Pure (MiniParse.Spec.Base.parser_spec t2) | Prims.Pure | [] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Combinators.and_then",
"MiniParse.Spec.Combinators.parse_fret",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.eq2",
"Prims.l_True"
] | [] | false | false | false | false | false | let parse_synth' (#t1 #t2: Type0) (p1: parser_spec t1) (f2: (t1 -> GTot t2))
: Pure (parser_spec t2)
(requires (forall (x: t1) (x': t1). f2 x == f2 x' ==> x == x'))
(ensures (fun _ -> True)) =
| (and_then p1 (fun v1 -> parse_fret f2 v1)) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.parse_filter | val parse_filter (#t: Type0) (p: parser_spec t) (f: (t -> GTot bool))
: Tot (parser_spec (x: t{f x == true})) | val parse_filter (#t: Type0) (p: parser_spec t) (f: (t -> GTot bool))
: Tot (parser_spec (x: t{f x == true})) | let parse_filter
(#t: Type0)
(p: parser_spec t)
(f: (t -> GTot bool))
: Tot (parser_spec (x: t { f x == true }))
= p `and_then` (parse_filter_payload f) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 710,
"start_col": 0,
"start_line": 705
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v)
let synth_inverse
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . f2 (g1 x) == x)
let parse_synth'
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
: Pure (parser_spec t2)
(requires (
forall (x x' : t1) . f2 x == f2 x' ==> x == x'
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
: Pure (parser_spec t2)
(requires (
synth_inverse g1 f2
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth_eq
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(b: bytes)
: Lemma
(requires (synth_inverse g1 f2))
(ensures (parse (parse_synth p1 f2 g1) b == (match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed))))
= ()
val bare_serialize_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2)
let bare_serialize_synth #t1 #t2 p1 f2 s1 g1 =
fun (x: t2) -> serialize s1 (g1 x)
val bare_serialize_synth_correct
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
synth_inverse g1 f2 /\
synth_inverse f2 g1
))
(ensures (serializer_correct (parse_synth p1 f2 g1) (bare_serialize_synth p1 f2 s1 g1 )))
let bare_serialize_synth_correct #k #t1 p1 f2 s1 g1 =
()
let synth_inverse_intro
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let serialize_synth
(#t1: Type0)
(#t2: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(u: squash (
synth_inverse f2 g1 /\
synth_inverse g1 f2
))
: Tot (serializer_spec (parse_synth p1 f2 g1))
= bare_serialize_synth_correct p1 f2 s1 g1;
Serializer (bare_serialize_synth p1 f2 s1 g1)
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
unfold
let lift_parser
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (parser_spec t)
= let p = lift_parser' f in
no_lookahead_weak_ext p (coerce_to_bare_parser _ (f ()));
no_lookahead_ext p (coerce_to_bare_parser _ (f ()));
injective_ext p (coerce_to_bare_parser _ (f ()));
Parser p
(** Refinements *)
let parse_filter_payload
(#t: Type0)
(f: (t -> GTot bool))
(v: t)
: Tot (parser_spec (x: t { f x == true }))
= lift_parser (fun () ->
if f v
then
let v' : (x: t { f x == true } ) = v in
(parse_ret v')
else fail_parser (x: t {f x == true} )
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | p: MiniParse.Spec.Base.parser_spec t -> f: (_: t -> Prims.GTot Prims.bool)
-> MiniParse.Spec.Base.parser_spec (x: t{f x == true}) | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.parser_spec",
"Prims.bool",
"MiniParse.Spec.Combinators.and_then",
"Prims.eq2",
"MiniParse.Spec.Combinators.parse_filter_payload"
] | [] | false | false | false | false | false | let parse_filter (#t: Type0) (p: parser_spec t) (f: (t -> GTot bool))
: Tot (parser_spec (x: t{f x == true})) =
| p `and_then` (parse_filter_payload f) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.serialize_synth | val serialize_synth
(#t1 #t2: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(u: squash (synth_inverse f2 g1 /\ synth_inverse g1 f2))
: Tot (serializer_spec (parse_synth p1 f2 g1)) | val serialize_synth
(#t1 #t2: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(u: squash (synth_inverse f2 g1 /\ synth_inverse g1 f2))
: Tot (serializer_spec (parse_synth p1 f2 g1)) | let serialize_synth
(#t1: Type0)
(#t2: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(u: squash (
synth_inverse f2 g1 /\
synth_inverse g1 f2
))
: Tot (serializer_spec (parse_synth p1 f2 g1))
= bare_serialize_synth_correct p1 f2 s1 g1;
Serializer (bare_serialize_synth p1 f2 s1 g1) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 667,
"start_col": 0,
"start_line": 654
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v)
let synth_inverse
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . f2 (g1 x) == x)
let parse_synth'
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
: Pure (parser_spec t2)
(requires (
forall (x x' : t1) . f2 x == f2 x' ==> x == x'
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
: Pure (parser_spec t2)
(requires (
synth_inverse g1 f2
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth_eq
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(b: bytes)
: Lemma
(requires (synth_inverse g1 f2))
(ensures (parse (parse_synth p1 f2 g1) b == (match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed))))
= ()
val bare_serialize_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2)
let bare_serialize_synth #t1 #t2 p1 f2 s1 g1 =
fun (x: t2) -> serialize s1 (g1 x)
val bare_serialize_synth_correct
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
synth_inverse g1 f2 /\
synth_inverse f2 g1
))
(ensures (serializer_correct (parse_synth p1 f2 g1) (bare_serialize_synth p1 f2 s1 g1 )))
let bare_serialize_synth_correct #k #t1 p1 f2 s1 g1 =
()
let synth_inverse_intro
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s1: MiniParse.Spec.Base.serializer_spec p1 ->
f2: (_: t1 -> Prims.GTot t2) ->
g1: (_: t2 -> Prims.GTot t1) ->
u450:
Prims.squash (MiniParse.Spec.Combinators.synth_inverse f2 g1 /\
MiniParse.Spec.Combinators.synth_inverse g1 f2)
-> MiniParse.Spec.Base.serializer_spec (MiniParse.Spec.Combinators.parse_synth p1 f2 g1) | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Base.serializer_spec",
"Prims.squash",
"Prims.l_and",
"MiniParse.Spec.Combinators.synth_inverse",
"MiniParse.Spec.Base.Serializer",
"MiniParse.Spec.Combinators.parse_synth",
"MiniParse.Spec.Combinators.bare_serialize_synth",
"Prims.unit",
"MiniParse.Spec.Combinators.bare_serialize_synth_correct"
] | [] | false | false | false | false | false | let serialize_synth
(#t1 #t2: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(u: squash (synth_inverse f2 g1 /\ synth_inverse g1 f2))
: Tot (serializer_spec (parse_synth p1 f2 g1)) =
| bare_serialize_synth_correct p1 f2 s1 g1;
Serializer (bare_serialize_synth p1 f2 s1 g1) | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.serialize_filter | val serialize_filter (#t: Type0) (#p: parser_spec t) (s: serializer_spec p) (f: (t -> GTot bool))
: Tot (serializer_spec (parse_filter p f)) | val serialize_filter (#t: Type0) (#p: parser_spec t) (s: serializer_spec p) (f: (t -> GTot bool))
: Tot (serializer_spec (parse_filter p f)) | let serialize_filter
(#t: Type0)
(#p: parser_spec t)
(s: serializer_spec p)
(f: (t -> GTot bool))
: Tot (serializer_spec (parse_filter p f))
= Serializer (serialize_filter' s f) | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 726,
"start_col": 0,
"start_line": 720
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2)
let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf
let serialize_nondep_then
(#t1: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(#p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (serializer_spec (nondep_then p1 p2))
= bare_serialize_nondep_then_correct p1 s1 p2 s2;
Serializer (bare_serialize_nondep_then p1 s1 p2 s2)
/// monadic return for the parser monad
unfold
let parse_fret' (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (bare_parser t') =
fun (b: bytes) -> Some (f v, (0 <: consumed_length b))
unfold
let parse_fret (#t #t':Type) (f: t -> GTot t') (v:t) : Tot (parser_spec t') =
Parser (parse_fret' f v)
let synth_inverse
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: GTot Type0
= (forall (x : t2) . f2 (g1 x) == x)
let parse_synth'
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
: Pure (parser_spec t2)
(requires (
forall (x x' : t1) . f2 x == f2 x' ==> x == x'
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
: Pure (parser_spec t2)
(requires (
synth_inverse g1 f2
))
(ensures (fun _ -> True))
= (and_then p1 (fun v1 -> parse_fret f2 v1))
let parse_synth_eq
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(b: bytes)
: Lemma
(requires (synth_inverse g1 f2))
(ensures (parse (parse_synth p1 f2 g1) b == (match parse p1 b with
| None -> None
| Some (x1, consumed) -> Some (f2 x1, consumed))))
= ()
val bare_serialize_synth
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Tot (bare_serializer t2)
let bare_serialize_synth #t1 #t2 p1 f2 s1 g1 =
fun (x: t2) -> serialize s1 (g1 x)
val bare_serialize_synth_correct
(#t1: Type0)
(#t2: Type0)
(p1: parser_spec t1)
(f2: t1 -> GTot t2)
(s1: serializer_spec p1)
(g1: t2 -> GTot t1)
: Lemma
(requires (
synth_inverse g1 f2 /\
synth_inverse f2 g1
))
(ensures (serializer_correct (parse_synth p1 f2 g1) (bare_serialize_synth p1 f2 s1 g1 )))
let bare_serialize_synth_correct #k #t1 p1 f2 s1 g1 =
()
let synth_inverse_intro
(#t1: Type0)
(#t2: Type0)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
: Lemma
(requires (forall (x : t2) . f2 (g1 x) == x))
(ensures (synth_inverse f2 g1))
= ()
let serialize_synth
(#t1: Type0)
(#t2: Type0)
(#p1: parser_spec t1)
(s1: serializer_spec p1)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(u: squash (
synth_inverse f2 g1 /\
synth_inverse g1 f2
))
: Tot (serializer_spec (parse_synth p1 f2 g1))
= bare_serialize_synth_correct p1 f2 s1 g1;
Serializer (bare_serialize_synth p1 f2 s1 g1)
(** Tot vs. Ghost *)
unfold
let lift_parser'
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (bare_parser t)
= fun (input: bytes) -> parse (f ()) input
unfold
let lift_parser
(#t: Type0)
(f: unit -> GTot (parser_spec t))
: Tot (parser_spec t)
= let p = lift_parser' f in
no_lookahead_weak_ext p (coerce_to_bare_parser _ (f ()));
no_lookahead_ext p (coerce_to_bare_parser _ (f ()));
injective_ext p (coerce_to_bare_parser _ (f ()));
Parser p
(** Refinements *)
let parse_filter_payload
(#t: Type0)
(f: (t -> GTot bool))
(v: t)
: Tot (parser_spec (x: t { f x == true }))
= lift_parser (fun () ->
if f v
then
let v' : (x: t { f x == true } ) = v in
(parse_ret v')
else fail_parser (x: t {f x == true} )
)
let parse_filter
(#t: Type0)
(p: parser_spec t)
(f: (t -> GTot bool))
: Tot (parser_spec (x: t { f x == true }))
= p `and_then` (parse_filter_payload f)
let serialize_filter'
(#t: Type0)
(#p: parser_spec t)
(s: serializer_spec p)
(f: (t -> GTot bool))
: Tot (bare_serializer (x: t { f x == true } ))
= fun (input: t { f input == true } ) -> serialize s input | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: MiniParse.Spec.Base.serializer_spec p -> f: (_: t -> Prims.GTot Prims.bool)
-> MiniParse.Spec.Base.serializer_spec (MiniParse.Spec.Combinators.parse_filter p f) | Prims.Tot | [
"total"
] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Base.serializer_spec",
"Prims.bool",
"MiniParse.Spec.Base.Serializer",
"Prims.eq2",
"MiniParse.Spec.Combinators.parse_filter",
"MiniParse.Spec.Combinators.serialize_filter'"
] | [] | false | false | false | false | false | let serialize_filter (#t: Type0) (#p: parser_spec t) (s: serializer_spec p) (f: (t -> GTot bool))
: Tot (serializer_spec (parse_filter p f)) =
| Serializer (serialize_filter' s f) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_fold_equals_fold_of_seq | val matrix_fold_equals_fold_of_seq :
(#c:Type) -> (#eq:CE.equiv c) -> (#m:pos) -> (#n:pos) -> (cm: CE.cm c eq) -> (mx:matrix c m n)
-> Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)] | val matrix_fold_equals_fold_of_seq :
(#c:Type) -> (#eq:CE.equiv c) -> (#m:pos) -> (#n:pos) -> (cm: CE.cm c eq) -> (mx:matrix c m n)
-> Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)] | let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 68,
"start_col": 0,
"start_line": 66
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | cm: FStar.Algebra.CommMonoid.Equiv.cm c eq -> mx: FStar.Matrix.matrix c m n
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Matrix.foldm cm mx)
(FStar.Seq.Permutation.foldm_snoc cm (FStar.Matrix.seq_of_matrix mx)))
[SMTPat (FStar.Matrix.foldm cm mx)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Matrix.foldm",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Matrix.seq_of_matrix",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures (foldm cm mx) `eq.eq` (SP.foldm_snoc cm (seq_of_matrix mx)))
[SMTPat (foldm cm mx)] =
| eq.reflexivity (foldm cm mx) | false |
FStar.Matrix.fst | FStar.Matrix.seq_of_matrix | val seq_of_matrix : (#c: Type) -> (#m:pos) -> (#n:pos) -> (mx: matrix c m n) ->
(s:SB.seq c {
SB.length s=m*n /\
(forall (ij: under (m*n)). SB.index s ij == SB.index s (get_ij m n (get_i m n ij) (get_j m n ij)))
}) | val seq_of_matrix : (#c: Type) -> (#m:pos) -> (#n:pos) -> (mx: matrix c m n) ->
(s:SB.seq c {
SB.length s=m*n /\
(forall (ij: under (m*n)). SB.index s ij == SB.index s (get_ij m n (get_i m n ij) (get_j m n ij)))
}) | let seq_of_matrix #c #m #n mx = mx | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 55,
"start_col": 0,
"start_line": 55
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n } | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | mx: FStar.Matrix.matrix c m n
-> s:
FStar.Seq.Base.seq c
{ FStar.Seq.Base.length s = m * n /\
(forall (ij: FStar.IntegerIntervals.under (m * n)).
FStar.Seq.Base.index s ij ==
FStar.Seq.Base.index s
(FStar.Matrix.get_ij m n (FStar.Matrix.get_i m n ij) (FStar.Matrix.get_j m n ij))) } | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.Matrix.matrix",
"FStar.Seq.Base.seq",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Mul.op_Star",
"Prims.l_Forall",
"FStar.IntegerIntervals.under",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Matrix.get_ij",
"FStar.Matrix.get_i",
"FStar.Matrix.get_j"
] | [] | false | false | false | false | false | let seq_of_matrix #c #m #n mx =
| mx | false |
FStar.Matrix.fst | FStar.Matrix.ijth | val ijth : (#c:Type) -> (#m:pos) -> (#n:pos) -> (mx: matrix c m n) -> (i: under m) -> (j: under n) ->
(t:c{t == SB.index (seq_of_matrix mx) (get_ij m n i j)}) | val ijth : (#c:Type) -> (#m:pos) -> (#n:pos) -> (mx: matrix c m n) -> (i: under m) -> (j: under n) ->
(t:c{t == SB.index (seq_of_matrix mx) (get_ij m n i j)}) | let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 55,
"end_line": 57,
"start_col": 0,
"start_line": 57
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
mx: FStar.Matrix.matrix c m n ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under n
-> t: c{t == FStar.Seq.Base.index (FStar.Matrix.seq_of_matrix mx) (FStar.Matrix.get_ij m n i j)} | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"FStar.Seq.Base.index",
"FStar.Matrix.get_ij",
"Prims.eq2",
"FStar.Matrix.seq_of_matrix"
] | [] | false | false | false | false | false | let ijth #c #m #n mx i j =
| SB.index mx (get_ij m n i j) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_eq_fun | val matrix_eq_fun : eq: FStar.Algebra.CommMonoid.Equiv.equiv c ->
ma: FStar.Matrix.matrix c m n ->
mb: FStar.Matrix.matrix c m n
-> Prims.prop | let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 52,
"end_line": 430,
"start_col": 0,
"start_line": 429
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
eq: FStar.Algebra.CommMonoid.Equiv.equiv c ->
ma: FStar.Matrix.matrix c m n ->
mb: FStar.Matrix.matrix c m n
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Matrix.matrix",
"FStar.Seq.Equiv.eq_of_seq",
"FStar.Matrix.seq_of_matrix",
"Prims.prop"
] | [] | false | false | false | false | true | let matrix_eq_fun #c (#m: pos) (#n: pos) (eq: CE.equiv c) (ma: matrix c m n) (mb: matrix c m n) =
| eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb) | false |
|
FStar.Matrix.fst | FStar.Matrix.matrix_seq | val matrix_seq (#c #m #n: _) (gen: matrix_generator c m n)
: (t:
SB.seq c
{ (SB.length t = (m * n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall (ij: under (m * n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij)) }) | val matrix_seq (#c #m #n: _) (gen: matrix_generator c m n)
: (t:
SB.seq c
{ (SB.length t = (m * n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall (ij: under (m * n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij)) }) | let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 99,
"start_col": 8,
"start_line": 96
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | gen: FStar.Matrix.matrix_generator c m n
-> t:
FStar.Seq.Base.seq c
{ FStar.Seq.Base.length t = m * n /\
(forall (i: FStar.IntegerIntervals.under m) (j: FStar.IntegerIntervals.under n).
FStar.Seq.Base.index t (FStar.Matrix.get_ij m n i j) == gen i j) /\
(forall (ij: FStar.IntegerIntervals.under (m * n)).
FStar.Seq.Base.index t ij == gen (FStar.Matrix.get_i m n ij) (FStar.Matrix.get_j m n ij)
) } | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.Matrix.matrix_generator",
"FStar.Matrix.init",
"FStar.Seq.Base.seq",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Mul.op_Star",
"Prims.l_Forall",
"FStar.IntegerIntervals.under",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Matrix.get_ij",
"FStar.Matrix.get_i",
"FStar.Matrix.get_j"
] | [] | false | false | false | false | false | let matrix_seq #c #m #n (gen: matrix_generator c m n)
: (t:
SB.seq c
{ (SB.length t = (m * n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall (ij: under (m * n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij)) }) =
| init gen | false |
FStar.Matrix.fst | FStar.Matrix.terminal_case_aux | val terminal_case_aux
(#c #eq: _)
(#p: pos{p = 1})
(#n: _)
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m <= p})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))))
)) | val terminal_case_aux
(#c #eq: _)
(#p: pos{p = 1})
(#n: _)
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m <= p})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))))
)) | let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 187,
"start_col": 0,
"start_line": 184
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
generator: FStar.Matrix.matrix_generator c p n ->
m: Prims.pos{m <= p}
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.slice (FStar.Matrix.seq_of_matrix (FStar.Matrix.init generator))
0
(m * n)))
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.init m
(fun i -> FStar.Seq.Permutation.foldm_snoc cm (FStar.Seq.Base.init n (generator i)))
))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix_generator",
"Prims.op_LessThanOrEqual",
"FStar.Matrix.one_row_matrix_fold_aux",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.slice",
"FStar.Matrix.seq_of_matrix",
"FStar.Matrix.init",
"FStar.Mul.op_Star",
"FStar.Seq.Base.init",
"FStar.IntegerIntervals.under",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let terminal_case_aux
#c
#eq
(#p: pos{p = 1})
#n
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m <= p})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))))
)) =
| one_row_matrix_fold_aux cm generator | false |
FStar.Matrix.fst | FStar.Matrix.matrix_append_snoc_lemma | val matrix_append_snoc_lemma (#c: _) (#m #n: pos) (generator: matrix_generator c m n)
: Lemma
(matrix_seq generator ==
(SB.slice (matrix_seq generator) 0 ((m - 1) * n))
`SB.append`
(SB.slice (matrix_seq generator) ((m - 1) * n) (m * n))) | val matrix_append_snoc_lemma (#c: _) (#m #n: pos) (generator: matrix_generator c m n)
: Lemma
(matrix_seq generator ==
(SB.slice (matrix_seq generator) 0 ((m - 1) * n))
`SB.append`
(SB.slice (matrix_seq generator) ((m - 1) * n) (m * n))) | let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 76,
"end_line": 109,
"start_col": 0,
"start_line": 103
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | generator: FStar.Matrix.matrix_generator c m n
-> FStar.Pervasives.Lemma
(ensures
FStar.Matrix.matrix_seq generator ==
FStar.Seq.Base.append (FStar.Seq.Base.slice (FStar.Matrix.matrix_seq generator)
0
((m - 1) * n))
(FStar.Seq.Base.slice (FStar.Matrix.matrix_seq generator) ((m - 1) * n) (m * n))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"FStar.Matrix.matrix_generator",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Matrix.matrix_seq",
"FStar.Seq.Base.append",
"FStar.Seq.Base.slice",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let matrix_append_snoc_lemma #c (#m: pos) (#n: pos) (generator: matrix_generator c m n)
: Lemma
(matrix_seq generator ==
(SB.slice (matrix_seq generator) 0 ((m - 1) * n))
`SB.append`
(SB.slice (matrix_seq generator) ((m - 1) * n) (m * n))) =
| SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m - 1) * n))
(SB.slice (matrix_seq generator) ((m - 1) * n) (m * n))) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_submatrix_lemma | val matrix_submatrix_lemma
(#c: _)
(#m: not_less_than 2)
(#n: pos)
(generator: matrix_generator c m n)
: Lemma
((matrix_seq generator) ==
((matrix_seq (fun (i: under (m - 1)) (j: under n) -> generator i j))
`SB.append`
(SB.init n (generator (m - 1))))) | val matrix_submatrix_lemma
(#c: _)
(#m: not_less_than 2)
(#n: pos)
(generator: matrix_generator c m n)
: Lemma
((matrix_seq generator) ==
((matrix_seq (fun (i: under (m - 1)) (j: under n) -> generator i j))
`SB.append`
(SB.init n (generator (m - 1))))) | let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 149,
"start_col": 0,
"start_line": 141
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would. | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | generator: FStar.Matrix.matrix_generator c m n
-> FStar.Pervasives.Lemma
(ensures
FStar.Matrix.matrix_seq generator ==
FStar.Seq.Base.append (FStar.Matrix.matrix_seq (fun i j -> generator i j))
(FStar.Seq.Base.init n (generator (m - 1)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.IntegerIntervals.not_less_than",
"Prims.pos",
"FStar.Matrix.matrix_generator",
"FStar.Matrix.matrix_seq_decomposition_lemma",
"Prims.unit",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.slice",
"FStar.Matrix.matrix_seq",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"FStar.Seq.Base.init",
"FStar.IntegerIntervals.under",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.append",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos) (generator: matrix_generator c m n)
: Lemma
((matrix_seq generator) ==
((matrix_seq (fun (i: under (m - 1)) (j: under n) -> generator i j))
`SB.append`
(SB.init n (generator (m - 1))))) =
| SB.lemma_eq_elim (matrix_seq (fun (i: under (m - 1)) (j: under n) -> generator i j))
(matrix_seq #c #(m - 1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m - 1) * n) (m * n))
(SB.init n (generator (m - 1)));
matrix_seq_decomposition_lemma generator | false |
MiniParse.Spec.Combinators.fst | MiniParse.Spec.Combinators.bare_serialize_nondep_then_correct | val bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2))) | val bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2))) | let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2)))
= let prf
(x: t1 * t2)
: Lemma (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)))
= let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (_, len')) = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1) (serialize s1 (fst x)) (bare_serialize_nondep_then p1 s1 p2 s2 x));
let (Some (x1, len1)) = v1 in
let (Some (x1', len1')) = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x == Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) == Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf | {
"file_name": "examples/miniparse/MiniParse.Spec.Combinators.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 545,
"start_col": 0,
"start_line": 507
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 MiniParse.Spec.Combinators
include MiniParse.Spec.Base
module Seq = FStar.Seq
module U8 = FStar.UInt8
module U32 = FStar.UInt32
(** Constant-size parsers *)
let make_constant_size_parser_aux
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Tot (bare_parser t)
= fun (s: bytes) ->
if Seq.length s < sz
then None
else begin
let s' : bytes = Seq.slice s 0 sz in
match f s' with
| None -> None
| Some v ->
let (sz: consumed_length s) = sz in
Some (v, sz)
end
let make_constant_size_parser_precond_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
(s1: bytes { Seq.length s1 == sz } )
(s2: bytes { Seq.length s2 == sz } )
: GTot Type0
= (Some? (f s1) \/ Some? (f s2)) /\ f s1 == f s2
let make_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> Seq.equal s1 s2
let make_constant_size_parser_precond'
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
make_constant_size_parser_precond_precond sz t f s1 s2 ==> s1 == s2
let make_constant_size_parser_injective
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Lemma
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (
injective (make_constant_size_parser_aux sz t f)
))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
let prf1
(b1 b2: bytes)
: Lemma
(requires (injective_precond p b1 b2))
(ensures (injective_postcond p b1 b2))
= assert (Some? (bparse p b1));
assert (Some? (bparse p b2));
let (Some (v1, len1)) = bparse p b1 in
let (Some (v2, len2)) = bparse p b2 in
assert ((len1 <: nat) == (len2 <: nat));
assert ((len1 <: nat) == sz);
assert ((len2 <: nat) == sz);
assert (make_constant_size_parser_precond_precond sz t f (Seq.slice b1 0 len1) (Seq.slice b2 0 len2));
assert (make_constant_size_parser_precond' sz t f)
in
Classical.forall_intro_2 (fun (b1: bytes) -> Classical.move_requires (prf1 b1))
let make_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (option t)))
: Pure (parser_spec t)
(requires (
make_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= let p : bare_parser t = make_constant_size_parser_aux sz t f in
make_constant_size_parser_injective sz t f;
Parser p
let make_total_constant_size_parser_precond
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: GTot Type0
= forall (s1: bytes {Seq.length s1 == sz}) (s2: bytes {Seq.length s2 == sz}) .
f s1 == f s2 ==> Seq.equal s1 s2
let make_total_constant_size_parser
(sz: nat)
(t: Type0)
(f: ((s: bytes {Seq.length s == sz}) -> GTot t))
: Pure (parser_spec t)
(requires (
make_total_constant_size_parser_precond sz t f
))
(ensures (fun _ -> True))
= make_constant_size_parser sz t (fun x -> Some (f x))
(** Combinators *)
/// monadic return for the parser monad
unfold
let parse_ret' (#t:Type) (v:t) : Tot (bare_parser t) =
fun (b: bytes) -> Some (v, (0 <: consumed_length b))
let parse_ret (#t:Type) (v:t) : Tot (parser_spec t) =
Parser (parse_ret' v)
let parse_empty : parser_spec unit =
parse_ret ()
let serialize_empty : serializer_spec parse_empty =
Serializer (fun _ -> Seq.empty)
#set-options "--z3rlimit 16"
let fail_parser'
(t: Type0)
: Tot (bare_parser t)
= fun _ -> None
let fail_parser
(t: Type0)
: Tot (parser_spec t)
= let p = fail_parser' t in
Parser p
/// monadic bind for the parser monad
val and_then_bare : #t:Type -> #t':Type ->
p:bare_parser t ->
p': (t -> Tot (bare_parser t')) ->
Tot (bare_parser t')
let and_then_bare #t #t' p p' =
fun (b: bytes) ->
match bparse p b with
| Some (v, l) ->
begin
let p'v = p' v in
let s' : bytes = Seq.slice b l (Seq.length b) in
match bparse p'v s' with
| Some (v', l') ->
let res : consumed_length b = l + l' in
Some (v', res)
| None -> None
end
| None -> None
val and_then_no_lookahead_weak_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak_on (and_then_bare p p') x x'))
let and_then_no_lookahead_weak_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.length x' <= Seq.length x /\ Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (bparse f x') /\ (
let (Some v') = bparse f x' in
let (y', off') = v' in
y == y' /\ (off <: nat) == (off' <: nat)
)))
= assert (Some? (bparse p x));
let (Some (y1, off1)) = bparse p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_weak_on p x x');
assert (Some? (bparse p x'));
let (Some v1') = bparse p x' in
let (y1', off1') = v1' in
assert (y1 == y1' /\ (off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (bparse p2 x2));
let (Some (y', off2)) = bparse p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.length x2' <= Seq.length x2);
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_weak_on p2 x2 x2');
()
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead_weak
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
no_lookahead_weak p /\
(forall (x: t) . no_lookahead_weak (p' x))
))
(ensures (no_lookahead_weak (and_then_bare p p')))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_weak_on p p' x))
let and_then_cases_injective_precond
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
(x1 x2: t)
(b1 b2: bytes)
: GTot Type0
= Some? ((p' x1) b1) /\
Some? ((p' x2) b2) /\ (
let (Some (v1, _)) = (p' x1) b1 in
let (Some (v2, _)) = (p' x2) b2 in
v1 == v2
)
let and_then_cases_injective'
(#t:Type)
(#t':Type)
(p': (t -> Tot (bare_parser t')))
: GTot Type0
= forall (x1 x2: t) (b1 b2: bytes) .
and_then_cases_injective_precond p' x1 x2 b1 b2 ==>
x1 == x2
let coerce_to_bare_param_parser
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
(x: t)
: Tot (bare_parser t')
= coerce_to_bare_parser _ (p' x)
let and_then_cases_injective
(#t: Type)
(#t' : Type)
(p' : (t -> Tot (parser_spec t')))
: GTot Type0
= and_then_cases_injective' (coerce_to_bare_param_parser p')
val and_then_injective
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
: Lemma
(requires (
injective p /\
(forall (x: t) . injective (p' x)) /\
and_then_cases_injective' p'
))
(ensures (
injective (and_then_bare p p')
))
let and_then_injective #t #t' p p' =
let ps = and_then_bare p p' in
let f
(b1 b2: bytes)
: Lemma
(requires (injective_precond ps b1 b2))
(ensures (injective_postcond ps b1 b2))
= let (Some (v1, len1)) = p b1 in
let (Some (v2, len2)) = p b2 in
let b1' : bytes = Seq.slice b1 len1 (Seq.length b1) in
let b2' : bytes = Seq.slice b2 len2 (Seq.length b2) in
assert (Some? ((p' v1) b1'));
assert (Some? ((p' v2) b2'));
assert (and_then_cases_injective_precond p' v1 v2 b1' b2');
assert (v1 == v2);
assert (injective_precond p b1 b2);
assert ((len1 <: nat) == (len2 <: nat));
assert (injective (p' v1));
assert (injective_precond (p' v1) b1' b2');
assert (injective_postcond (p' v1) b1' b2');
let (Some (_, len1')) = (p' v1) b1' in
let (Some (_, len2')) = (p' v2) b2' in
assert ((len1' <: nat) == (len2' <: nat));
Seq.lemma_split (Seq.slice b1 0 (len1 + len1')) len1;
Seq.lemma_split (Seq.slice b2 0 (len2 + len2')) len1;
assert (injective_postcond ps b1 b2)
in
Classical.forall_intro_2 (fun x -> Classical.move_requires (f x))
val and_then_no_lookahead_on
(#t:Type)
(#t':Type)
(p: bare_parser t)
(p': (t -> Tot (bare_parser t')))
(x: bytes)
(x' : bytes)
: Lemma
(requires (
no_lookahead p /\
injective p /\
(forall (x: t) . no_lookahead (p' x))
))
(ensures (no_lookahead_on (and_then_bare p p') x x'))
let and_then_no_lookahead_on #t #t' p p' x x' =
let f = and_then_bare p p' in
match f x with
| Some v ->
let (y, off) = v in
let off : nat = off in
let (off_x : consumed_length x ) = off in
if off <= Seq.length x'
then
let (off_x' : consumed_length x') = off in
let g () : Lemma
(requires (Seq.slice x' 0 off_x' == Seq.slice x 0 off_x))
(ensures (
Some? (f x') /\ (
let (Some v') = f x' in
let (y', off') = v' in
y == y'
)))
= assert (Some? (p x));
let (Some (y1, off1)) = p x in
assert (off1 <= off);
assert (off1 <= Seq.length x');
assert (Seq.slice x' 0 off1 == Seq.slice (Seq.slice x' 0 off_x') 0 off1);
assert (Seq.slice x' 0 off1 == Seq.slice x 0 off1);
assert (no_lookahead_on p x x');
assert (Some? (p x'));
let (Some v1') = p x' in
let (y1', off1') = v1' in
assert (y1 == y1');
assert (injective_precond p x x');
assert ((off1 <: nat) == (off1' <: nat));
let x2 : bytes = Seq.slice x off1 (Seq.length x) in
let x2' : bytes = Seq.slice x' off1 (Seq.length x') in
let p2 = p' y1 in
assert (Some? (p2 x2));
let (Some (y2, off2)) = p2 x2 in
assert (off == off1 + off2);
assert (off2 <= Seq.length x2);
assert (off2 <= Seq.length x2');
assert (Seq.slice x2' 0 off2 == Seq.slice (Seq.slice x' 0 off_x') off1 (off1 + off2));
assert (Seq.slice x2' 0 off2 == Seq.slice x2 0 off2);
assert (no_lookahead_on p2 x2 x2');
assert (Some? (p2 x2'));
let (Some v2') = p2 x2' in
let (y2', _) = v2' in
assert (y2 == y2')
in
Classical.move_requires g ()
else ()
| _ -> ()
let and_then_no_lookahead
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (and_then_no_lookahead_on (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') x))
#set-options "--max_fuel 8 --max_ifuel 8 --z3rlimit 64"
let and_then_correct
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Lemma
(requires (
and_then_cases_injective p'
))
(ensures (
no_lookahead_weak (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
injective (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p')) /\
no_lookahead (and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p'))
))
= and_then_no_lookahead_weak (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_injective (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p');
and_then_no_lookahead p p'
#reset-options
val and_then
(#t:Type)
(p:parser_spec t)
(#t':Type)
(p': (t -> Tot (parser_spec t')))
: Pure (parser_spec t')
(requires (
and_then_cases_injective p'
))
(ensures (fun _ -> True))
let and_then #t p #t' p' =
let f : bare_parser t' = and_then_bare (coerce_to_bare_parser _ p) (coerce_to_bare_param_parser p') in
and_then_correct p p' ;
Parser f
(* Special case for non-dependent parsing *)
#set-options "--z3rlimit 16"
let nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
: Tot (parser_spec (t1 * t2))
= p1 `and_then` (fun v1 -> p2 `and_then` (fun v2 -> (parse_ret (v1, v2))))
let nondep_then_eq
(#t1: Type0)
(p1: parser_spec t1)
(#t2: Type0)
(p2: parser_spec t2)
(b: bytes)
: Lemma
(parse (nondep_then p1 p2) b == (match parse p1 b with
| Some (x1, consumed1) ->
let b' = Seq.slice b consumed1 (Seq.length b) in
begin match parse p2 b' with
| Some (x2, consumed2) ->
Some ((x1, x2), consumed1 + consumed2)
| _ -> None
end
| _ -> None
))
= ()
let bare_serialize_nondep_then
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Tot (bare_serializer (t1 * t2))
= fun (x: t1 * t2) ->
let (x1, x2) = x in
Seq.append (serialize s1 x1) (serialize s2 x2)
let seq_slice_append_l
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) 0 (Seq.length s1) == s1)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) 0 (Seq.length s1)) s1)
let seq_slice_append_r
(#t: Type)
(s1 s2: Seq.seq t)
: Lemma
(Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2)) == s2)
= assert (Seq.equal (Seq.slice (Seq.append s1 s2) (Seq.length s1) (Seq.length (Seq.append s1 s2))) s2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"MiniParse.Spec.Base.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "MiniParse.Spec.Combinators.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "MiniParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "MiniParse.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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
p1: MiniParse.Spec.Base.parser_spec t1 ->
s1: MiniParse.Spec.Base.serializer_spec p1 ->
p2: MiniParse.Spec.Base.parser_spec t2 ->
s2: MiniParse.Spec.Base.serializer_spec p2
-> FStar.Pervasives.Lemma
(ensures
MiniParse.Spec.Base.serializer_correct (MiniParse.Spec.Combinators.nondep_then p1 p2)
(MiniParse.Spec.Combinators.bare_serialize_nondep_then p1 s1 p2 s2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"MiniParse.Spec.Base.parser_spec",
"MiniParse.Spec.Base.serializer_spec",
"FStar.Classical.forall_intro",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"MiniParse.Spec.Base.consumed_length",
"MiniParse.Spec.Combinators.bare_serialize_nondep_then",
"MiniParse.Spec.Base.parse",
"MiniParse.Spec.Combinators.nondep_then",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Base.length",
"MiniParse.Spec.Base.byte",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"MiniParse.Spec.Base.serialize",
"FStar.Pervasives.Native.fst",
"Prims._assert",
"MiniParse.Spec.Combinators.seq_slice_append_r",
"FStar.Pervasives.Native.snd",
"MiniParse.Spec.Base.bytes",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.append",
"Prims.nat",
"MiniParse.Spec.Base.injective_postcond",
"MiniParse.Spec.Base.coerce_to_bare_parser",
"MiniParse.Spec.Base.injective_precond",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"MiniParse.Spec.Base.no_lookahead_on_postcond",
"MiniParse.Spec.Base.no_lookahead_on_precond",
"MiniParse.Spec.Combinators.seq_slice_append_l",
"FStar.Seq.Base.slice",
"Prims.op_LessThanOrEqual",
"MiniParse.Spec.Base.no_lookahead_on",
"MiniParse.Spec.Base.serializer_correct"
] | [] | false | false | true | false | false | let bare_serialize_nondep_then_correct
(#t1: Type0)
(p1: parser_spec t1)
(s1: serializer_spec p1)
(#t2: Type0)
(p2: parser_spec t2)
(s2: serializer_spec p2)
: Lemma
(ensures (serializer_correct (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2))) =
| let prf (x: t1 * t2)
: Lemma
(parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) ==
Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x))) =
let v1' = parse p1 (bare_serialize_nondep_then p1 s1 p2 s2 x) in
let v1 = parse p1 (serialize s1 (fst x)) in
assert (Some? v1);
assert (no_lookahead_on (coerce_to_bare_parser _ p1)
(serialize s1 (fst x))
(bare_serialize_nondep_then p1 s1 p2 s2 x));
let Some (_, len') = parse p1 (serialize s1 (fst x)) in
assert (len' == Seq.length (serialize s1 (fst x)));
assert (len' <= Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Seq.slice (serialize s1 (fst x)) 0 len' == serialize s1 (fst x));
seq_slice_append_l (serialize s1 (fst x)) (serialize s2 (snd x));
assert (no_lookahead_on_precond (coerce_to_bare_parser _ p1)
(serialize s1 (fst x))
(bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (no_lookahead_on_postcond (coerce_to_bare_parser _ p1)
(serialize s1 (fst x))
(bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (Some? v1');
assert (injective_precond (coerce_to_bare_parser _ p1)
(serialize s1 (fst x))
(bare_serialize_nondep_then p1 s1 p2 s2 x));
assert (injective_postcond (coerce_to_bare_parser _ p1)
(serialize s1 (fst x))
(bare_serialize_nondep_then p1 s1 p2 s2 x));
let Some (x1, len1) = v1 in
let Some (x1', len1') = v1' in
assert (x1 == x1');
assert ((len1 <: nat) == (len1' <: nat));
assert (x1 == fst x);
assert (len1 == Seq.length (serialize s1 (fst x)));
assert (bare_serialize_nondep_then p1 s1 p2 s2 x ==
Seq.append (serialize s1 (fst x)) (serialize s2 (snd x)));
let s = bare_serialize_nondep_then p1 s1 p2 s2 x in
seq_slice_append_r (serialize s1 (fst x)) (serialize s2 (snd x));
assert (parse (nondep_then p1 p2) (bare_serialize_nondep_then p1 s1 p2 s2 x) ==
Some (x, Seq.length (bare_serialize_nondep_then p1 s1 p2 s2 x)));
()
in
Classical.forall_intro prf | false |
FStar.Matrix.fst | FStar.Matrix.matrix_seq_of_one_row_matrix | val matrix_seq_of_one_row_matrix (#c #m #n: _) (generator: matrix_generator c m n)
: Lemma (requires m == 1) (ensures matrix_seq generator == (SB.init n (generator 0))) | val matrix_seq_of_one_row_matrix (#c #m #n: _) (generator: matrix_generator c m n)
: Lemma (requires m == 1) (ensures matrix_seq generator == (SB.init n (generator 0))) | let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0)) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 67,
"end_line": 154,
"start_col": 0,
"start_line": 151
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | generator: FStar.Matrix.matrix_generator c m n
-> FStar.Pervasives.Lemma (requires m == 1)
(ensures FStar.Matrix.matrix_seq generator == FStar.Seq.Base.init n (generator 0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"FStar.Matrix.matrix_generator",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Matrix.matrix_seq",
"FStar.Seq.Base.init",
"Prims.unit",
"Prims.eq2",
"Prims.int",
"Prims.squash",
"FStar.Seq.Base.seq",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let matrix_seq_of_one_row_matrix #c #m #n (generator: matrix_generator c m n)
: Lemma (requires m == 1) (ensures matrix_seq generator == (SB.init n (generator 0))) =
| SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0)) | false |
FStar.Matrix.fst | FStar.Matrix.math_aux_2 | val math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j + (m - 1) * n) == j) | val math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j + (m - 1) * n) == j) | let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 217,
"start_col": 0,
"start_line": 214
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | m: Prims.pos -> n: Prims.pos -> j: FStar.IntegerIntervals.under n
-> FStar.Pervasives.Lemma (ensures FStar.Matrix.get_j m n (j + (m - 1) * n) == j) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"FStar.IntegerIntervals.under",
"FStar.Math.Lemmas.small_mod",
"Prims.unit",
"FStar.Math.Lemmas.modulo_addition_lemma",
"Prims.op_Subtraction",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Matrix.get_j",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j + (m - 1) * n) == j) =
| Math.Lemmas.modulo_addition_lemma j n (m - 1);
Math.Lemmas.small_mod j n | false |
FStar.Matrix.fst | FStar.Matrix.init | val init : (#c:Type) -> (#m:pos) -> (#n: pos) -> (generator: matrix_generator c m n)
-> matrix_of generator | val init : (#c:Type) -> (#m:pos) -> (#n: pos) -> (generator: matrix_generator c m n)
-> matrix_of generator | let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 8,
"end_line": 94,
"start_col": 0,
"start_line": 75
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | generator: FStar.Matrix.matrix_generator c m n -> FStar.Matrix.matrix_of generator | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.Matrix.matrix_generator",
"Prims.unit",
"FStar.Classical.forall_intro_2",
"FStar.IntegerIntervals.under",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Seq.Properties.map_seq",
"FStar.Matrix.get_ij",
"FStar.Classical.forall_intro",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Seq.Properties.map_seq_index",
"Prims._assert",
"FStar.Matrix.consistency_of_ij",
"FStar.Matrix.consistency_of_i_j",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.map_seq_len",
"FStar.Seq.Base.seq",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.l_Forall",
"FStar.IntegerIntervals.indices_seq",
"Prims.op_Multiply",
"FStar.Mul.op_Star",
"FStar.Matrix.get_i",
"FStar.Matrix.get_j",
"Prims.int",
"FStar.Matrix.matrix_of"
] | [] | false | false | false | false | false | let init #c (#m: pos) (#n: pos) (generator: matrix_generator c m n) : matrix_of generator =
| let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j) =
consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j)
in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij) =
SProp.map_seq_index generator_ij flat_indices ij
in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result | false |
Hacl.Impl.Ed25519.Ladder.fst | Hacl.Impl.Ed25519.Ladder.precomp_get_consttime | val precomp_get_consttime: BE.pow_a_to_small_b_st U64 20ul 0ul mk_ed25519_concrete_ops 4ul 16ul
(BE.table_inv_precomp 20ul 0ul mk_ed25519_concrete_ops 4ul 16ul) | val precomp_get_consttime: BE.pow_a_to_small_b_st U64 20ul 0ul mk_ed25519_concrete_ops 4ul 16ul
(BE.table_inv_precomp 20ul 0ul mk_ed25519_concrete_ops 4ul 16ul) | let precomp_get_consttime ctx a table bits_l tmp =
[@inline_let] let len = 20ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_ed25519_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.lprecomp_get_consttime len ctx_len k l table_len ctx a table bits_l tmp | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Ladder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 76,
"end_line": 109,
"start_col": 0,
"start_line": 102
} | module Hacl.Impl.Ed25519.Ladder
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module BSeq = Lib.ByteSequence
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExponentiation
module PT = Hacl.Impl.PrecompTable
module SPT256 = Hacl.Spec.PrecompBaseTable256
module BD = Hacl.Bignum.Definitions
module SD = Hacl.Spec.Bignum.Definitions
module S = Spec.Ed25519
open Hacl.Impl.Ed25519.PointConstants
include Hacl.Impl.Ed25519.Group
include Hacl.Ed25519.PrecompTable
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let table_inv_w4 : BE.table_inv_t U64 20ul 16ul =
[@inline_let] let len = 20ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_ed25519_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len
inline_for_extraction noextract
let table_inv_w5 : BE.table_inv_t U64 20ul 32ul =
[@inline_let] let len = 20ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_ed25519_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
assert_norm (pow2 (v l) = v table_len);
BE.table_inv_precomp len ctx_len k l table_len
inline_for_extraction noextract
val convert_scalar: scalar:lbuffer uint8 32ul -> bscalar:lbuffer uint64 4ul ->
Stack unit
(requires fun h -> live h scalar /\ live h bscalar /\ disjoint scalar bscalar)
(ensures fun h0 _ h1 -> modifies (loc bscalar) h0 h1 /\
BD.bn_v h1 bscalar == BSeq.nat_from_bytes_le (as_seq h0 scalar))
let convert_scalar scalar bscalar =
let h0 = ST.get () in
Hacl.Spec.Bignum.Convert.bn_from_bytes_le_lemma #U64 32 (as_seq h0 scalar);
Hacl.Bignum.Convert.mk_bn_from_bytes_le true 32ul scalar bscalar
inline_for_extraction noextract
val point_mul_noalloc:
out:point
-> bscalar:lbuffer uint64 4ul
-> q:point ->
Stack unit
(requires fun h ->
live h bscalar /\ live h q /\ live h out /\
disjoint q out /\ disjoint q bscalar /\ disjoint out bscalar /\
F51.point_inv_t h q /\ F51.inv_ext_point (as_seq h q) /\
BD.bn_v h bscalar < pow2 256)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
F51.point_inv_t h1 out /\ F51.inv_ext_point (as_seq h1 out) /\
S.to_aff_point (F51.point_eval h1 out) ==
LE.exp_fw S.mk_ed25519_comm_monoid
(S.to_aff_point (F51.point_eval h0 q)) 256 (BD.bn_v h0 bscalar) 4)
let point_mul_noalloc out bscalar q =
BE.lexp_fw_consttime 20ul 0ul mk_ed25519_concrete_ops
4ul (null uint64) q 4ul 256ul bscalar out
let point_mul out scalar q =
let h0 = ST.get () in
SE.exp_fw_lemma S.mk_ed25519_concrete_ops
(F51.point_eval h0 q) 256 (BSeq.nat_from_bytes_le (as_seq h0 scalar)) 4;
push_frame ();
let bscalar = create 4ul (u64 0) in
convert_scalar scalar bscalar;
point_mul_noalloc out bscalar q;
pop_frame ()
val precomp_get_consttime: BE.pow_a_to_small_b_st U64 20ul 0ul mk_ed25519_concrete_ops 4ul 16ul
(BE.table_inv_precomp 20ul 0ul mk_ed25519_concrete_ops 4ul 16ul) | {
"checked_file": "/",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable256.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Convert.fst.checked",
"Hacl.Impl.PrecompTable.fsti.checked",
"Hacl.Impl.MultiExponentiation.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"Hacl.Impl.Ed25519.PointNegate.fst.checked",
"Hacl.Impl.Ed25519.PointConstants.fst.checked",
"Hacl.Impl.Ed25519.Group.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Ed25519.PrecompTable.fsti.checked",
"Hacl.Bignum25519.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Convert.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Impl.Ed25519.Ladder.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Ed25519.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.PointConstants",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.PrecompTable",
"short_module": "PT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.MultiExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"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.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"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
}
] | {
"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"
} | false | Hacl.Impl.Exponentiation.pow_a_to_small_b_st Lib.IntTypes.U64
20ul
0ul
Hacl.Impl.Ed25519.Group.mk_ed25519_concrete_ops
4ul
16ul
(Hacl.Impl.Exponentiation.table_inv_precomp 20ul
0ul
Hacl.Impl.Ed25519.Group.mk_ed25519_concrete_ops
4ul
16ul) | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.__uint_to_t",
"FStar.Ghost.erased",
"Lib.Sequence.lseq",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.clbuffer",
"Lib.IntTypes.op_Star_Bang",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Hacl.Impl.Exponentiation.lprecomp_get_consttime",
"Prims.unit",
"FStar.UInt32.t",
"Hacl.Impl.Exponentiation.Definitions.concrete_ops",
"FStar.UInt32.uint_to_t",
"Hacl.Impl.Ed25519.Group.mk_ed25519_concrete_ops"
] | [] | false | false | false | false | false | let precomp_get_consttime ctx a table bits_l tmp =
| [@@ inline_let ]let len = 20ul in
[@@ inline_let ]let ctx_len = 0ul in
[@@ inline_let ]let k = mk_ed25519_concrete_ops in
[@@ inline_let ]let l = 4ul in
[@@ inline_let ]let table_len = 16ul in
BE.lprecomp_get_consttime len ctx_len k l table_len ctx a table bits_l tmp | false |
FStar.Matrix.fst | FStar.Matrix.fold_of_subgen_aux | val fold_of_subgen_aux
(#c #eq: _)
(#m: pos{m > 1})
(#n: _)
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
(subgen: matrix_generator c (m - 1) n)
: Lemma (requires subgen == (fun (i: under (m - 1)) (j: under n) -> gen i j))
(ensures
forall (i: under (m - 1)).
SP.foldm_snoc cm (SB.init n (subgen i)) == SP.foldm_snoc cm (SB.init n (gen i))) | val fold_of_subgen_aux
(#c #eq: _)
(#m: pos{m > 1})
(#n: _)
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
(subgen: matrix_generator c (m - 1) n)
: Lemma (requires subgen == (fun (i: under (m - 1)) (j: under n) -> gen i j))
(ensures
forall (i: under (m - 1)).
SP.foldm_snoc cm (SB.init n (subgen i)) == SP.foldm_snoc cm (SB.init n (gen i))) | let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 180,
"start_col": 0,
"start_line": 173
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
gen: FStar.Matrix.matrix_generator c m n ->
subgen: FStar.Matrix.matrix_generator c (m - 1) n
-> FStar.Pervasives.Lemma (requires subgen == (fun i j -> gen i j))
(ensures
forall (i: FStar.IntegerIntervals.under (m - 1)).
FStar.Seq.Permutation.foldm_snoc cm (FStar.Seq.Base.init n (subgen i)) ==
FStar.Seq.Permutation.foldm_snoc cm (FStar.Seq.Base.init n (gen i))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix_generator",
"Prims.op_Subtraction",
"FStar.Classical.forall_intro",
"FStar.IntegerIntervals.under",
"Prims.eq2",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Seq.Base.lemma_eq_elim",
"Prims.l_Forall"
] | [] | false | false | true | false | false | let fold_of_subgen_aux
#c
#eq
(#m: pos{m > 1})
#n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
(subgen: matrix_generator c (m - 1) n)
: Lemma (requires subgen == (fun (i: under (m - 1)) (j: under n) -> gen i j))
(ensures
forall (i: under (m - 1)).
SP.foldm_snoc cm (SB.init n (subgen i)) == SP.foldm_snoc cm (SB.init n (gen i))) =
| let aux_pat (i: under (m - 1))
: Lemma (SP.foldm_snoc cm (SB.init n (subgen i)) == SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i))
in
Classical.forall_intro aux_pat | false |
FStar.Matrix.fst | FStar.Matrix.math_aux_3 | val math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j + (m - 1) * n) == (m - 1)) | val math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j + (m - 1) * n) == (m - 1)) | let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 222,
"start_col": 0,
"start_line": 219
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | m: Prims.pos -> n: Prims.pos -> j: FStar.IntegerIntervals.under n
-> FStar.Pervasives.Lemma (ensures FStar.Matrix.get_i m n (j + (m - 1) * n) == m - 1) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"FStar.IntegerIntervals.under",
"FStar.Math.Lemmas.small_div",
"Prims.unit",
"FStar.Math.Lemmas.division_addition_lemma",
"Prims.op_Subtraction",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"FStar.Matrix.get_i",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j + (m - 1) * n) == (m - 1)) =
| Math.Lemmas.division_addition_lemma j n (m - 1);
Math.Lemmas.small_div j n | false |
FStar.Matrix.fst | FStar.Matrix.matrix_fold_equals_func_double_fold | val matrix_fold_equals_func_double_fold : (#c:Type) -> (#eq: CE.equiv c) ->
(#m: pos) -> (#n: pos) ->
(cm: CE.cm c eq) ->
(generator: matrix_generator c m n) ->
Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i))) | val matrix_fold_equals_func_double_fold : (#c:Type) -> (#eq: CE.equiv c) ->
(#m: pos) -> (#n: pos) ->
(cm: CE.cm c eq) ->
(generator: matrix_generator c m n) ->
Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i))) | let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 370,
"start_col": 0,
"start_line": 367
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | cm: FStar.Algebra.CommMonoid.Equiv.cm c eq -> generator: FStar.Matrix.matrix_generator c m n
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Matrix.foldm cm (FStar.Matrix.init generator))
(FStar.Algebra.CommMonoid.Fold.fold cm
0
(m - 1)
(fun i -> FStar.Algebra.CommMonoid.Fold.fold cm 0 (n - 1) (generator i)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix_generator",
"FStar.Matrix.matrix_fold_aux",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.foldm",
"FStar.Matrix.init",
"FStar.Algebra.CommMonoid.Fold.fold",
"Prims.op_Subtraction",
"FStar.IntegerIntervals.under",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma
((foldm cm (init generator))
`eq.eq`
(CF.fold cm 0 (m - 1) (fun (i: under m) -> CF.fold cm 0 (n - 1) (generator i)))) =
| matrix_fold_aux cm m n generator | false |
FStar.Matrix.fst | FStar.Matrix.transposed_matrix_gen | val transposed_matrix_gen (#c:_) (#m:pos) (#n:pos) (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j }) | val transposed_matrix_gen (#c:_) (#m:pos) (#n:pos) (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j }) | let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 377,
"start_col": 0,
"start_line": 375
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | generator: FStar.Matrix.matrix_generator c m n
-> f:
FStar.Matrix.matrix_generator c n m
{ forall (i: FStar.IntegerIntervals.under m) (j: FStar.IntegerIntervals.under n).
f j i == generator i j } | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"FStar.Matrix.matrix_generator",
"FStar.IntegerIntervals.under",
"Prims.l_Forall",
"Prims.eq2"
] | [] | false | false | false | false | false | let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m {forall i j. f j i == generator i j}) =
| fun j i -> generator i j | false |
FStar.Matrix.fst | FStar.Matrix.matrix_fold_equals_fold_of_seq_folds | val matrix_fold_equals_fold_of_seq_folds : (#c:Type) -> (#eq: CE.equiv c) ->
(#m: pos) -> (#n: pos) ->
(cm: CE.cm c eq) ->
(generator: matrix_generator c m n) ->
Lemma (ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
/\ SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
) | val matrix_fold_equals_fold_of_seq_folds : (#c:Type) -> (#eq: CE.equiv c) ->
(#m: pos) -> (#n: pos) ->
(cm: CE.cm c eq) ->
(generator: matrix_generator c m n) ->
Lemma (ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
/\ SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
) | let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
() | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 2,
"end_line": 299,
"start_col": 0,
"start_line": 288
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | cm: FStar.Algebra.CommMonoid.Equiv.cm c eq -> generator: FStar.Matrix.matrix_generator c m n
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Matrix.foldm cm (FStar.Matrix.init generator))
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.init m
(fun i -> FStar.Seq.Permutation.foldm_snoc cm (FStar.Seq.Base.init n (generator i)))
)) /\
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Matrix.seq_of_matrix (FStar.Matrix.init generator)))
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.init m
(fun i -> FStar.Seq.Permutation.foldm_snoc cm (FStar.Seq.Base.init n (generator i)))
))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix_generator",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.init",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.IntegerIntervals.under",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.slice",
"FStar.Matrix.seq_of_matrix",
"FStar.Matrix.init",
"FStar.Mul.op_Star",
"FStar.Matrix.matrix_fold_equals_double_fold",
"Prims.l_True",
"Prims.squash",
"Prims.l_and",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.foldm",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator
: Lemma
(ensures
(foldm cm (init generator))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) /\
(SP.foldm_snoc cm (seq_of_matrix (init generator)))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))))) =
| matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m * n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
() | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul | val matrix_mul (#c:_) (#eq:_) (#m #n #p:pos) (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
: matrix c m p | val matrix_mul (#c:_) (#eq:_) (#m #n #p:pos) (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
: matrix c m p | let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 523,
"start_col": 0,
"start_line": 522
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mx: FStar.Matrix.matrix c m n ->
my: FStar.Matrix.matrix c n p
-> FStar.Matrix.matrix c m p | Prims.Tot | [
"total"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix",
"FStar.Matrix.init",
"FStar.Matrix.matrix_mul_gen"
] | [] | false | false | false | false | false | let matrix_mul
#c
#eq
#m
#n
#p
(add: CE.cm c eq)
(mul: CE.cm c eq)
(mx: matrix c m n)
(my: matrix c n p)
=
| init (matrix_mul_gen add mul mx my) | false |
FStar.Matrix.fst | FStar.Matrix.seq_eq_from_member_eq | val seq_eq_from_member_eq
(#c: _)
(n: pos)
(p q: (z: SB.seq c {SB.length z = n}))
(proof: (i: under n -> Lemma (SB.index p i == SB.index q i)))
: Lemma (p == q) | val seq_eq_from_member_eq
(#c: _)
(n: pos)
(p q: (z: SB.seq c {SB.length z = n}))
(proof: (i: under n -> Lemma (SB.index p i == SB.index q i)))
: Lemma (p == q) | let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 230,
"start_col": 0,
"start_line": 226
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
n: Prims.pos ->
p: z: FStar.Seq.Base.seq c {FStar.Seq.Base.length z = n} ->
q: z: FStar.Seq.Base.seq c {FStar.Seq.Base.length z = n} ->
proof:
(i: FStar.IntegerIntervals.under n
-> FStar.Pervasives.Lemma (ensures FStar.Seq.Base.index p i == FStar.Seq.Base.index q i))
-> FStar.Pervasives.Lemma (ensures p == q) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.IntegerIntervals.under",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Seq.Base.index",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Classical.forall_intro"
] | [] | false | false | true | false | false | let seq_eq_from_member_eq
#c
(n: pos)
(p: (z: SB.seq c {SB.length z = n}))
(q: (z: SB.seq c {SB.length z = n}))
(proof: (i: under n -> Lemma (SB.index p i == SB.index q i)))
: Lemma (p == q) =
| Classical.forall_intro proof;
SB.lemma_eq_elim p q | false |
FStar.Matrix.fst | FStar.Matrix.matrix_add_is_associative | val matrix_add_is_associative (#c #eq #m #n: _) (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma
((matrix_add add (matrix_add add ma mb) mc)
`(matrix_equiv eq m n).eq`
(matrix_add add ma (matrix_add add mb mc))) | val matrix_add_is_associative (#c #eq #m #n: _) (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma
((matrix_add add (matrix_add add ma mb) mc)
`(matrix_equiv eq m n).eq`
(matrix_add add ma (matrix_add add mb mc))) | let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j)) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 76,
"end_line": 467,
"start_col": 0,
"start_line": 461
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
ma: FStar.Matrix.matrix c m n ->
mb: FStar.Matrix.matrix c m n ->
mc: FStar.Matrix.matrix c m n
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq (FStar.Matrix.matrix_equiv eq m n)
(FStar.Matrix.matrix_add add (FStar.Matrix.matrix_add add ma mb) mc)
(FStar.Matrix.matrix_add add ma (FStar.Matrix.matrix_add add mb mc))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_proof",
"FStar.Matrix.matrix_add",
"FStar.IntegerIntervals.under",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__associativity",
"FStar.Matrix.ijth",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.matrix_equiv",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let matrix_add_is_associative
#c
#eq
#m
#n
(add: CE.cm c eq)
(ma: matrix c m n)
(mb: matrix c m n)
(mc: matrix c m n)
: Lemma
((matrix_add add (matrix_add add ma mb) mc)
`(matrix_equiv eq m n).eq`
(matrix_add add ma (matrix_add add mb mc))) =
| matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j)) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_equiv | val matrix_equiv : (#c: Type) ->
(eq: CE.equiv c) ->
(m: pos) -> (n: pos) ->
CE.equiv (matrix c m n) | val matrix_equiv : (#c: Type) ->
(eq: CE.equiv c) ->
(m: pos) -> (n: pos) ->
CE.equiv (matrix c m n) | let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc)) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 108,
"end_line": 441,
"start_col": 0,
"start_line": 437
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above. | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | eq: FStar.Algebra.CommMonoid.Equiv.equiv c -> m: Prims.pos -> n: Prims.pos
-> FStar.Algebra.CommMonoid.Equiv.equiv (FStar.Matrix.matrix c m n) | Prims.Tot | [
"total"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.EQ",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_eq_fun",
"FStar.Seq.Equiv.eq_of_seq_reflexivity",
"FStar.Matrix.seq_of_matrix",
"Prims.unit",
"FStar.Seq.Equiv.eq_of_seq_symmetry",
"FStar.Seq.Equiv.eq_of_seq_transitivity"
] | [] | false | false | false | false | false | let matrix_equiv #c (eq: CE.equiv c) (m: pos) (n: pos) : CE.equiv (matrix c m n) =
| CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc ->
eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc)) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_add_congruence | val matrix_add_congruence (#c #eq: _) (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_eq_fun eq (matrix_add add ma mb) (matrix_add add mc md)) | val matrix_add_congruence (#c #eq: _) (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_eq_fun eq (matrix_add add ma mb) (matrix_add add mc md)) | let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j)) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 78,
"end_line": 481,
"start_col": 0,
"start_line": 474
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
ma: FStar.Matrix.matrix c m n ->
mb: FStar.Matrix.matrix c m n ->
mc: FStar.Matrix.matrix c m n ->
md: FStar.Matrix.matrix c m n
-> FStar.Pervasives.Lemma
(requires FStar.Matrix.matrix_eq_fun eq ma mc /\ FStar.Matrix.matrix_eq_fun eq mb md)
(ensures
FStar.Matrix.matrix_eq_fun eq
(FStar.Matrix.matrix_add add ma mb)
(FStar.Matrix.matrix_add add mc md)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_proof",
"FStar.Matrix.matrix_add",
"FStar.IntegerIntervals.under",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Matrix.ijth",
"Prims.unit",
"FStar.Matrix.matrix_equiv_ijth",
"Prims.l_and",
"FStar.Matrix.matrix_eq_fun",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let matrix_add_congruence
#c
#eq
(#m: pos)
(#n: pos)
(add: CE.cm c eq)
(ma: matrix c m n)
(mb: matrix c m n)
(mc: matrix c m n)
(md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_eq_fun eq (matrix_add add ma mb) (matrix_add add mc md)) =
| matrix_equiv_from_proof eq
(matrix_add add ma mb)
(matrix_add add mc md)
(fun i j ->
matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j) (ijth mc i j) (ijth md i j)) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_seq_decomposition_lemma | val matrix_seq_decomposition_lemma
(#c: _)
(#m: greater_than 1)
(#n: pos)
(generator: matrix_generator c m n)
: Lemma
((matrix_seq generator) ==
SB.append (matrix_seq #c #(m - 1) #n generator)
(SB.slice (matrix_seq generator) ((m - 1) * n) (m * n))) | val matrix_seq_decomposition_lemma
(#c: _)
(#m: greater_than 1)
(#n: pos)
(generator: matrix_generator c m n)
: Lemma
((matrix_seq generator) ==
SB.append (matrix_seq #c #(m - 1) #n generator)
(SB.slice (matrix_seq generator) ((m - 1) * n) (m * n))) | let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 68,
"end_line": 117,
"start_col": 0,
"start_line": 111
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | generator: FStar.Matrix.matrix_generator c m n
-> FStar.Pervasives.Lemma
(ensures
FStar.Matrix.matrix_seq generator ==
FStar.Seq.Base.append (FStar.Matrix.matrix_seq generator)
(FStar.Seq.Base.slice (FStar.Matrix.matrix_seq generator) ((m - 1) * n) (m * n))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.IntegerIntervals.greater_than",
"Prims.pos",
"FStar.Matrix.matrix_generator",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Matrix.matrix_seq",
"FStar.Seq.Base.append",
"Prims.op_Subtraction",
"FStar.Seq.Base.slice",
"FStar.Mul.op_Star",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let matrix_seq_decomposition_lemma
#c
(#m: greater_than 1)
(#n: pos)
(generator: matrix_generator c m n)
: Lemma
((matrix_seq generator) ==
SB.append (matrix_seq #c #(m - 1) #n generator)
(SB.slice (matrix_seq generator) ((m - 1) * n) (m * n))) =
| SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m - 1) #n generator)
`SB.append`
(SB.slice (matrix_seq generator) ((m - 1) * n) (m * n))) | false |
FStar.Matrix.fst | FStar.Matrix.liat_equals_init | val liat_equals_init (#c: _) (m: pos) (gen: (under m -> c))
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m - 1) gen) | val liat_equals_init (#c: _) (m: pos) (gen: (under m -> c))
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m - 1) gen) | let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 76,
"end_line": 210,
"start_col": 0,
"start_line": 208
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | m: Prims.pos -> gen: (_: FStar.IntegerIntervals.under m -> c)
-> FStar.Pervasives.Lemma
(ensures
FStar.Pervasives.Native.fst (FStar.Seq.Properties.un_snoc (FStar.Seq.Base.init m gen)) ==
FStar.Seq.Base.init (m - 1) gen) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"FStar.IntegerIntervals.under",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Pervasives.Native.fst",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.un_snoc",
"FStar.Seq.Base.init",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let liat_equals_init #c (m: pos) (gen: (under m -> c))
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m - 1) gen) =
| SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m - 1) gen) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_add_identity | val matrix_add_identity (#c #eq: _) (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_eq_fun eq (matrix_add add (matrix_add_zero add m n) mx) mx) | val matrix_add_identity (#c #eq: _) (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_eq_fun eq (matrix_add add (matrix_add_zero add m n) mx) mx) | let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j)) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 490,
"start_col": 0,
"start_line": 487
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | add: FStar.Algebra.CommMonoid.Equiv.cm c eq -> mx: FStar.Matrix.matrix c m n
-> FStar.Pervasives.Lemma
(ensures
FStar.Matrix.matrix_eq_fun eq
(FStar.Matrix.matrix_add add (FStar.Matrix.matrix_add_zero add m n) mx)
mx) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"Prims.pos",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_proof",
"FStar.Matrix.matrix_add",
"FStar.Matrix.matrix_add_zero",
"FStar.IntegerIntervals.under",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__identity",
"FStar.Matrix.ijth",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Matrix.matrix_eq_fun",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let matrix_add_identity #c #eq (add: CE.cm c eq) (#m: pos) (#n: pos) (mx: matrix c m n)
: Lemma (matrix_eq_fun eq (matrix_add add (matrix_add_zero add m n) mx) mx) =
| matrix_equiv_from_proof eq
(matrix_add add (matrix_add_zero add m n) mx)
mx
(fun i j -> add.identity (ijth mx i j)) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_fold_snoc_lemma | val matrix_fold_snoc_lemma
(#c #eq: _)
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma
(assert ((m - 1) * n < m * n);
(SP.foldm_snoc cm (matrix_seq generator))
`eq.eq`
(cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m - 1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m - 1) * n) (m * n))))) | val matrix_fold_snoc_lemma
(#c #eq: _)
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma
(assert ((m - 1) * n < m * n);
(SP.foldm_snoc cm (matrix_seq generator))
`eq.eq`
(cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m - 1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m - 1) * n) (m * n))))) | let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 74,
"end_line": 134,
"start_col": 0,
"start_line": 121
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | cm: FStar.Algebra.CommMonoid.Equiv.cm c eq -> generator: FStar.Matrix.matrix_generator c m n
-> FStar.Pervasives.Lemma
(ensures
(assert ((m - 1) * n < m * n);
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc cm (FStar.Matrix.matrix_seq generator))
(CM?.mult cm
(FStar.Seq.Permutation.foldm_snoc cm (FStar.Matrix.matrix_seq generator))
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.slice (FStar.Matrix.matrix_seq generator) ((m - 1) * n) (m * n))))
)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.IntegerIntervals.not_less_than",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix_generator",
"FStar.Seq.Permutation.foldm_snoc_append",
"FStar.Matrix.matrix_seq",
"Prims.op_Subtraction",
"FStar.Seq.Base.slice",
"FStar.Mul.op_Star",
"Prims.unit",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.append",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let matrix_fold_snoc_lemma
#c
#eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma
(assert ((m - 1) * n < m * n);
(SP.foldm_snoc cm (matrix_seq generator))
`eq.eq`
(cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m - 1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m - 1) * n) (m * n))))) =
| SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m - 1) #n generator)
`SB.append`
(SB.slice (matrix_seq generator) ((m - 1) * n) (m * n)));
SP.foldm_snoc_append cm
(matrix_seq #c #(m - 1) #n generator)
(SB.slice (matrix_seq generator) ((m - 1) * n) (m * n)) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_add_zero | val matrix_add_zero (#c #eq: _) (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n {forall (i: under m) (j: under n). ijth z i j == add.unit}) | val matrix_add_zero (#c #eq: _) (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n {forall (i: under m) (j: under n). ijth z i j == add.unit}) | let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 485,
"start_col": 0,
"start_line": 483
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | add: FStar.Algebra.CommMonoid.Equiv.cm c eq -> m: Prims.pos -> n: Prims.pos
-> z:
FStar.Matrix.matrix c m n
{ forall (i: FStar.IntegerIntervals.under m) (j: FStar.IntegerIntervals.under n).
FStar.Matrix.ijth z i j == CM?.unit add } | Prims.Tot | [
"total"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"Prims.pos",
"FStar.Matrix.matrix_of_seq",
"FStar.Seq.Base.create",
"FStar.Mul.op_Star",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"Prims.l_Forall",
"FStar.IntegerIntervals.under",
"Prims.eq2",
"FStar.Matrix.ijth"
] | [] | false | false | false | false | false | let matrix_add_zero #c #eq (add: CE.cm c eq) (m: pos) (n: pos)
: (z: matrix c m n {forall (i: under m) (j: under n). ijth z i j == add.unit}) =
| matrix_of_seq m n (SB.create (m * n) add.unit) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_add_is_commutative | val matrix_add_is_commutative (#c #eq: _) (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma ((matrix_add add ma mb) `(matrix_equiv eq m n).eq` (matrix_add add mb ma)) | val matrix_add_is_commutative (#c #eq: _) (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma ((matrix_add add ma mb) `(matrix_equiv eq m n).eq` (matrix_add add mb ma)) | let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j)) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 472,
"start_col": 0,
"start_line": 469
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
ma: FStar.Matrix.matrix c m n ->
mb: FStar.Matrix.matrix c m n
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq (FStar.Matrix.matrix_equiv eq m n)
(FStar.Matrix.matrix_add add ma mb)
(FStar.Matrix.matrix_add add mb ma)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_proof",
"FStar.Matrix.matrix_add",
"FStar.IntegerIntervals.under",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__commutativity",
"FStar.Matrix.ijth",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.matrix_equiv",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let matrix_add_is_commutative
#c
#eq
(#m: pos)
(#n: pos)
(add: CE.cm c eq)
(ma: matrix c m n)
(mb: matrix c m n)
: Lemma ((matrix_add add ma mb) `(matrix_equiv eq m n).eq` (matrix_add add mb ma)) =
| matrix_equiv_from_proof eq
(matrix_add add ma mb)
(matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j)) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_transpose_is_permutation | val matrix_transpose_is_permutation (#c:_) (#m #n: pos)
(generator: matrix_generator c m n)
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) | val matrix_transpose_is_permutation (#c:_) (#m #n: pos)
(generator: matrix_generator c m n)
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) | let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 45,
"end_line": 405,
"start_col": 0,
"start_line": 381
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | generator: FStar.Matrix.matrix_generator c m n
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Permutation.is_permutation (FStar.Matrix.seq_of_matrix (FStar.Matrix.init generator)
)
(FStar.Matrix.seq_of_matrix (FStar.Matrix.init (FStar.Matrix.transposed_matrix_gen generator
)))
(FStar.Matrix.transpose_ji m n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"FStar.Matrix.matrix_generator",
"FStar.Seq.Permutation.reveal_is_permutation",
"FStar.Matrix.seq_of_matrix",
"FStar.Matrix.init",
"FStar.Matrix.transposed_matrix_gen",
"FStar.Matrix.transpose_ji",
"Prims.unit",
"FStar.Classical.forall_intro_2",
"FStar.IntegerIntervals.under",
"FStar.Mul.op_Star",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_disEquality",
"Prims.int",
"Prims.l_or",
"FStar.IntegerIntervals.interval_condition",
"FStar.Classical.move_requires_2",
"FStar.Classical.forall_intro",
"Prims.eq2",
"FStar.Seq.Base.index",
"Prims.op_Multiply",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Matrix.dual_indices",
"Prims.l_True",
"FStar.Matrix.ijth_lemma",
"FStar.Matrix.get_i",
"FStar.Matrix.get_j",
"FStar.Seq.Permutation.is_permutation"
] | [] | false | false | true | false | false | let matrix_transpose_is_permutation #c #m #n generator
: Lemma
(SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
| let matrix_transposed_eq_lemma
#c
(#m: pos)
(#n: pos)
(gen: matrix_generator c m n)
(ij: under (m * n))
: Lemma
(SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij)) =
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
()
in
let transpose_inequality_lemma (m n: pos) (ij: under (m * n)) (kl: under (n * m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl
in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2 (transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_add_comm_monoid | val matrix_add_comm_monoid : (#c:Type) ->
(#eq:CE.equiv c) ->
(add: CE.cm c eq) ->
(m:pos) -> (n: pos) ->
CE.cm (matrix c m n) (matrix_equiv eq m n) | val matrix_add_comm_monoid : (#c:Type) ->
(#eq:CE.equiv c) ->
(add: CE.cm c eq) ->
(m:pos) -> (n: pos) ->
CE.cm (matrix c m n) (matrix_equiv eq m n) | let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 499,
"start_col": 0,
"start_line": 492
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | add: FStar.Algebra.CommMonoid.Equiv.cm c eq -> m: Prims.pos -> n: Prims.pos
-> FStar.Algebra.CommMonoid.Equiv.cm (FStar.Matrix.matrix c m n)
(FStar.Matrix.matrix_equiv eq m n) | Prims.Tot | [
"total"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.CM",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv",
"FStar.Matrix.matrix_add_zero",
"FStar.Matrix.matrix_add",
"FStar.Matrix.matrix_add_identity",
"FStar.Matrix.matrix_add_is_associative",
"FStar.Matrix.matrix_add_is_commutative",
"FStar.Matrix.matrix_add_congruence"
] | [] | false | false | false | false | false | let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m: pos) (n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n) =
| CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_equiv_from_element_eq | val matrix_equiv_from_element_eq (#c:_) (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures (matrix_equiv eq m n).eq ma mb) | val matrix_equiv_from_element_eq (#c:_) (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures (matrix_equiv eq m n).eq ma mb) | let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 74,
"end_line": 458,
"start_col": 0,
"start_line": 449
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
eq: FStar.Algebra.CommMonoid.Equiv.equiv c ->
ma: FStar.Matrix.matrix c m n ->
mb: FStar.Matrix.matrix c m n
-> FStar.Pervasives.Lemma
(requires
forall (i: FStar.IntegerIntervals.under m) (j: FStar.IntegerIntervals.under n).
EQ?.eq eq (FStar.Matrix.ijth ma i j) (FStar.Matrix.ijth mb i j))
(ensures EQ?.eq (FStar.Matrix.matrix_equiv eq m n) ma mb) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Matrix.matrix",
"FStar.Seq.Equiv.eq_of_seq_from_element_equality",
"FStar.Matrix.seq_of_matrix",
"Prims.unit",
"Prims._assert",
"Prims.l_Forall",
"FStar.IntegerIntervals.under",
"FStar.Mul.op_Star",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Base.index",
"Prims.eq2",
"FStar.Matrix.ijth",
"FStar.Matrix.get_i",
"FStar.Matrix.get_j",
"FStar.Seq.Base.seq",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.op_Multiply",
"FStar.Matrix.get_ij",
"Prims.nat",
"Prims.squash",
"FStar.Matrix.matrix_eq_fun",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let matrix_equiv_from_element_eq
#c
(#m: pos)
(#n: pos)
(eq: CE.equiv c)
(ma: matrix c m n)
(mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). (ijth ma i j) `eq.eq` (ijth mb i j)))
(ensures matrix_eq_fun eq ma mb) =
| assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m * n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m * n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m * n)). (SB.index s1 ij) `eq.eq` (SB.index s2 ij));
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb) | false |
FStar.Matrix.fst | FStar.Matrix.one_row_matrix_fold_aux | val one_row_matrix_fold_aux (#c #eq #m #n: _) (cm: CE.cm c eq) (generator: matrix_generator c m n)
: Lemma (requires m = 1)
(ensures
(foldm cm (init generator))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) /\
(SP.foldm_snoc cm (seq_of_matrix (init generator)))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))))) | val one_row_matrix_fold_aux (#c #eq #m #n: _) (cm: CE.cm c eq) (generator: matrix_generator c m n)
: Lemma (requires m = 1)
(ensures
(foldm cm (init generator))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) /\
(SP.foldm_snoc cm (seq_of_matrix (init generator)))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))))) | let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 170,
"start_col": 0,
"start_line": 156
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | cm: FStar.Algebra.CommMonoid.Equiv.cm c eq -> generator: FStar.Matrix.matrix_generator c m n
-> FStar.Pervasives.Lemma (requires m = 1)
(ensures
EQ?.eq eq
(FStar.Matrix.foldm cm (FStar.Matrix.init generator))
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.init m
(fun i ->
FStar.Seq.Permutation.foldm_snoc cm (FStar.Seq.Base.init n (generator i))))) /\
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Matrix.seq_of_matrix (FStar.Matrix.init generator)))
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.init m
(fun i ->
FStar.Seq.Permutation.foldm_snoc cm (FStar.Seq.Base.init n (generator i)))))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix_generator",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__symmetry",
"Prims.unit",
"FStar.Matrix.matrix_seq_of_one_row_matrix",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.create",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Permutation.foldm_snoc_singleton",
"FStar.Matrix.matrix_seq",
"FStar.Seq.Base.seq",
"Prims.l_and",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.op_Multiply",
"Prims.l_Forall",
"FStar.IntegerIntervals.under",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Matrix.get_ij",
"FStar.Matrix.get_i",
"FStar.Matrix.get_j",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.foldm",
"FStar.Matrix.init",
"FStar.Matrix.seq_of_matrix",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let one_row_matrix_fold_aux #c #eq #m #n (cm: CE.cm c eq) (generator: matrix_generator c m n)
: Lemma (requires m = 1)
(ensures
(foldm cm (init generator))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) /\
(SP.foldm_snoc cm (seq_of_matrix (init generator)))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))))) =
| let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs | false |
Hacl.HPKE.Curve64_CP256_SHA512.fsti | Hacl.HPKE.Curve64_CP256_SHA512.vale_p | val vale_p : Prims.logical | let vale_p = Vale.X64.CPU_Features_s.(adx_enabled /\ bmi2_enabled) | {
"file_name": "code/hpke/Hacl.HPKE.Curve64_CP256_SHA512.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 13,
"start_col": 0,
"start_line": 13
} | module Hacl.HPKE.Curve64_CP256_SHA512
open Hacl.Impl.HPKE
module S = Spec.Agile.HPKE
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash
noextract unfold
let cs:S.ciphersuite = (DH.DH_Curve25519, Hash.SHA2_256, S.Seal AEAD.CHACHA20_POLY1305, Hash.SHA2_512) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.HPKE.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Hacl.Impl.HPKE.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.HPKE.Curve64_CP256_SHA512.fsti"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"abbrev": true,
"full_module": "Spec.Agile.HPKE",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Prims.l_and",
"Prims.b2t",
"Vale.X64.CPU_Features_s.adx_enabled",
"Vale.X64.CPU_Features_s.bmi2_enabled"
] | [] | false | false | false | true | true | let vale_p =
| let open Vale.X64.CPU_Features_s in adx_enabled /\ bmi2_enabled | false |
|
FStar.Matrix.fst | FStar.Matrix.matrix_fold_equals_fold_of_transpose | val matrix_fold_equals_fold_of_transpose (#c:_) (#eq:_)
(#m #n: pos)
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) | val matrix_fold_equals_fold_of_transpose (#c:_) (#eq:_)
(#m #n: pos)
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) | let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen))) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 63,
"end_line": 427,
"start_col": 0,
"start_line": 408
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | cm: FStar.Algebra.CommMonoid.Equiv.cm c eq -> gen: FStar.Matrix.matrix_generator c m n
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Matrix.foldm cm (FStar.Matrix.init gen))
(FStar.Matrix.foldm cm (FStar.Matrix.init (FStar.Matrix.transposed_matrix_gen gen)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix_generator",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Matrix.foldm",
"FStar.Matrix.init",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Matrix.transposed_matrix_gen",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__symmetry",
"FStar.Matrix.matrix_fold_equals_fold_of_seq",
"FStar.Seq.Permutation.foldm_snoc_perm",
"FStar.Matrix.transpose_ji",
"FStar.Matrix.matrix_transpose_is_permutation",
"FStar.Seq.Base.seq",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.op_Multiply",
"Prims.l_Forall",
"FStar.IntegerIntervals.under",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Matrix.get_ij",
"FStar.Matrix.get_i",
"FStar.Matrix.get_j",
"FStar.Matrix.seq_of_matrix",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let matrix_fold_equals_fold_of_transpose #c #eq #m #n (cm: CE.cm c eq) (gen: matrix_generator c m n)
: Lemma ((foldm cm (init gen)) `eq.eq` (foldm cm (init (transposed_matrix_gen gen)))) =
| let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen) (matrix_seq (transposed_matrix_gen gen)) (transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen))
(SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen))) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_gen | val matrix_mul_gen : add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mx: FStar.Matrix.matrix c m n ->
my: FStar.Matrix.matrix c n p ->
i: FStar.IntegerIntervals.under m ->
k: FStar.IntegerIntervals.under p
-> c | let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 520,
"start_col": 0,
"start_line": 517
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mx: FStar.Matrix.matrix c m n ->
my: FStar.Matrix.matrix c n p ->
i: FStar.IntegerIntervals.under m ->
k: FStar.IntegerIntervals.under p
-> c | Prims.Tot | [
"total"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"FStar.Matrix.dot",
"FStar.Matrix.row",
"FStar.Matrix.col"
] | [] | false | false | false | false | false | let matrix_mul_gen
#c
#eq
#m
#n
#p
(add: CE.cm c eq)
(mul: CE.cm c eq)
(mx: matrix c m n)
(my: matrix c n p)
(i: under m)
(k: under p)
=
| dot add mul (row mx i) (col my k) | false |
|
FStar.Matrix.fst | FStar.Matrix.matrix_equiv_ijth | val matrix_equiv_ijth (#c:_) (#m #n: pos) (eq: CE.equiv c)
(ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb)
(ensures ijth ma i j `eq.eq` ijth mb i j) | val matrix_equiv_ijth (#c:_) (#m #n: pos) (eq: CE.equiv c)
(ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb)
(ensures ijth ma i j `eq.eq` ijth mb i j) | let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 69,
"end_line": 446,
"start_col": 0,
"start_line": 444
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
eq: FStar.Algebra.CommMonoid.Equiv.equiv c ->
ma: FStar.Matrix.matrix c m n ->
mb: FStar.Matrix.matrix c m n ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under n
-> FStar.Pervasives.Lemma (requires EQ?.eq (FStar.Matrix.matrix_equiv eq m n) ma mb)
(ensures EQ?.eq eq (FStar.Matrix.ijth ma i j) (FStar.Matrix.ijth mb i j)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"FStar.Seq.Equiv.eq_of_seq_element_equality",
"FStar.Matrix.seq_of_matrix",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.matrix_equiv",
"Prims.squash",
"FStar.Matrix.ijth",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let matrix_equiv_ijth
#c
(#m: pos)
(#n: pos)
(eq: CE.equiv c)
(ma: matrix c m n)
(mb: matrix c m n)
(i: under m)
(j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures (ijth ma i j) `eq.eq` (ijth mb i j)) =
| eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb) | false |
FStar.Matrix.fst | FStar.Matrix.foldm_snoc_distributivity_right_eq | val foldm_snoc_distributivity_right_eq
(#c #eq: _)
(mul add: CE.cm c eq)
(s: SB.seq c)
(a: c)
(r: SB.seq c)
: Lemma
(requires
is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures (mul.mult (SP.foldm_snoc add s) a) `eq.eq` (SP.foldm_snoc add r)) | val foldm_snoc_distributivity_right_eq
(#c #eq: _)
(mul add: CE.cm c eq)
(s: SB.seq c)
(a: c)
(r: SB.seq c)
: Lemma
(requires
is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures (mul.mult (SP.foldm_snoc add s) a) `eq.eq` (SP.foldm_snoc add r)) | let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 576,
"start_col": 0,
"start_line": 571
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
s: FStar.Seq.Base.seq c ->
a: c ->
r: FStar.Seq.Base.seq c
-> FStar.Pervasives.Lemma
(requires
FStar.Matrix.is_fully_distributive mul add /\ FStar.Matrix.is_absorber (CM?.unit add) mul /\
FStar.Seq.Base.equal r (FStar.Matrix.seq_op_const mul s a))
(ensures
EQ?.eq eq
(CM?.mult mul (FStar.Seq.Permutation.foldm_snoc add s) a)
(FStar.Seq.Permutation.foldm_snoc add r)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"FStar.Matrix.foldm_snoc_distributivity_right",
"Prims.unit",
"Prims.l_and",
"FStar.Matrix.is_fully_distributive",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Seq.Base.equal",
"FStar.Matrix.seq_op_const",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Seq.Permutation.foldm_snoc",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let foldm_snoc_distributivity_right_eq
#c
#eq
(mul: CE.cm c eq)
(add: CE.cm c eq)
(s: SB.seq c)
(a: c)
(r: SB.seq c)
: Lemma
(requires
is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures (mul.mult (SP.foldm_snoc add s) a) `eq.eq` (SP.foldm_snoc add r)) =
| foldm_snoc_distributivity_right mul add s a | false |
FStar.Matrix.fst | FStar.Matrix.matrix_fold_aux | val matrix_fold_aux
(#c #eq: _)
(#gen_m #gen_n: pos)
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m)
(n: ifrom_ito 1 gen_n)
(generator: matrix_generator c gen_m gen_n)
: Lemma
(ensures
(SP.foldm_snoc cm (matrix_seq #c #m #n generator))
`eq.eq`
(CF.fold cm 0 (m - 1) (fun (i: under m) -> CF.fold cm 0 (n - 1) (generator i))))
(decreases m) | val matrix_fold_aux
(#c #eq: _)
(#gen_m #gen_n: pos)
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m)
(n: ifrom_ito 1 gen_n)
(generator: matrix_generator c gen_m gen_n)
: Lemma
(ensures
(SP.foldm_snoc cm (matrix_seq #c #m #n generator))
`eq.eq`
(CF.fold cm 0 (m - 1) (fun (i: under m) -> CF.fold cm 0 (n - 1) (generator i))))
(decreases m) | let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 362,
"start_col": 0,
"start_line": 331
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"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": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
m: FStar.IntegerIntervals.ifrom_ito 1 gen_m ->
n: FStar.IntegerIntervals.ifrom_ito 1 gen_n ->
generator: FStar.Matrix.matrix_generator c gen_m gen_n
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc cm (FStar.Matrix.matrix_seq generator))
(FStar.Algebra.CommMonoid.Fold.fold cm
0
(m - 1)
(fun i -> FStar.Algebra.CommMonoid.Fold.fold cm 0 (n - 1) (generator i))))
(decreases m) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.IntegerIntervals.ifrom_ito",
"FStar.Matrix.matrix_generator",
"Prims.op_Equality",
"Prims.int",
"Prims._assert",
"Prims.eq2",
"FStar.Algebra.CommMonoid.Fold.fold",
"Prims.op_Subtraction",
"FStar.IntegerIntervals.under",
"Prims.unit",
"FStar.Algebra.CommMonoid.Fold.fold_singleton_lemma",
"FStar.Matrix.matrix_last_line_equals_gen_fold",
"FStar.Matrix.matrix_fold_equals_fold_of_seq",
"FStar.Matrix.init",
"Prims.bool",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Matrix.matrix_seq",
"FStar.Mul.op_Star",
"FStar.Matrix.matrix_fold_snoc_lemma",
"FStar.Algebra.CommMonoid.Fold.fold_snoc_decomposition",
"FStar.Algebra.CommMonoid.Fold.fold_equality",
"FStar.Matrix.matrix_fold_aux",
"FStar.Classical.forall_intro_3",
"Prims.l_imp",
"Prims.l_and",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Classical.move_requires_3",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.equal",
"Prims.squash",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.prop",
"Prims.Nil",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Permutation.foldm_snoc",
"Prims.nat",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Seq.Base.slice",
"FStar.Classical.forall_intro_2",
"FStar.Matrix.ijth",
"FStar.Seq.Base.index",
"FStar.Matrix.seq_of_matrix",
"FStar.Matrix.get_ij",
"FStar.Matrix.ijth_lemma",
"Prims.l_True"
] | [
"recursion"
] | false | false | true | false | false | let rec matrix_fold_aux
#c
#eq
(#gen_m: pos)
(#gen_n: pos)
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m)
(n: ifrom_ito 1 gen_n)
(generator: matrix_generator c gen_m gen_n)
: Lemma
(ensures
(SP.foldm_snoc cm (matrix_seq #c #m #n generator))
`eq.eq`
(CF.fold cm 0 (m - 1) (fun (i: under m) -> CF.fold cm 0 (n - 1) (generator i))))
(decreases m) =
| Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1
then
(matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i: under m) -> CF.fold cm 0 (n - 1) (generator i));
assert (CF.fold cm 0 (m - 1) (fun (i: under m) -> CF.fold cm 0 (n - 1) (generator i)) ==
CF.fold cm 0 (n - 1) (generator 0)))
else
(Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m - 1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n - 1) (generator i) in
let outer_func_on_subdomain (i: under (m - 1)) = CF.fold cm 0 (n - 1) (generator i) in
CF.fold_equality cm 0 (m - 2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m - 1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m - 1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m - 1) * n) (m * n)))
(CF.fold cm 0 (m - 2) outer_func)
(CF.fold cm 0 (n - 1) (generator (m - 1)))) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_last_line_equals_gen_fold | val matrix_last_line_equals_gen_fold
(#c #eq: _)
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma
((SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m - 1) * n) (m * n)))
`eq.eq`
(CF.fold cm 0 (n - 1) (generator (m - 1)))) | val matrix_last_line_equals_gen_fold
(#c #eq: _)
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma
((SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m - 1) * n) (m * n)))
`eq.eq`
(CF.fold cm 0 (n - 1) (generator (m - 1)))) | let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1))) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 326,
"start_col": 0,
"start_line": 303
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false | cm: FStar.Algebra.CommMonoid.Equiv.cm c eq -> generator: FStar.Matrix.matrix_generator c m n
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.slice (FStar.Matrix.matrix_seq generator) ((m - 1) * n) (m * n)))
(FStar.Algebra.CommMonoid.Fold.fold cm 0 (n - 1) (generator (m - 1)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix_generator",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Matrix.matrix_seq",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"FStar.IntegerIntervals.closed_interval_size",
"FStar.Algebra.CommMonoid.Fold.fold",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__symmetry",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.IntegerIntervals.counter_for",
"Prims.op_Addition",
"FStar.IntegerIntervals.ifrom_ito",
"FStar.Algebra.CommMonoid.Fold.init_func_from_expr",
"FStar.Algebra.CommMonoid.Fold.fold_equals_seq_foldm",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.equal",
"Prims.squash",
"Prims.eq2",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.prop",
"Prims.Nil",
"FStar.Seq.Base.lemma_eq_elim",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.init",
"Prims._assert",
"Prims.l_or",
"Prims.l_and",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.l_Forall",
"FStar.IntegerIntervals.under",
"FStar.Seq.Base.index",
"FStar.Matrix.get_ij",
"FStar.Matrix.get_i",
"FStar.Matrix.get_j",
"FStar.Matrix.seq_of_matrix",
"FStar.Matrix.init",
"FStar.Seq.Permutation.foldm_snoc",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.slice",
"Prims.l_True",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq"
] | [] | true | false | true | false | false | let matrix_last_line_equals_gen_fold
#c
#eq
(#m: pos)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma
((SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m - 1) * n) (m * n)))
`eq.eq`
(CF.fold cm 0 (n - 1) (generator (m - 1)))) =
| let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m - 1) * n) (m * n)) (init n (generator (m - 1)));
let g: ifrom_ito 0 (n - 1) -> c = generator (m - 1) in
CF.fold_equals_seq_foldm cm 0 (n - 1) g;
let gen = CF.init_func_from_expr g 0 (n - 1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n - 1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m - 1) * n) (m * n))
(init (closed_interval_size 0 (n - 1)) gen);
eq.symmetry (CF.fold cm 0 (n - 1) (generator (m - 1)))
(foldm_snoc cm (init (closed_interval_size 0 (n - 1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m - 1) * n) (m * n)))
(foldm_snoc cm (init (closed_interval_size 0 (n - 1)) gen))
(CF.fold cm 0 (n - 1) (generator (m - 1))) | false |
FStar.Matrix.fst | FStar.Matrix.foldm_snoc_distributivity_left_eq | val foldm_snoc_distributivity_left_eq
(#c #eq: _)
(mul add: CE.cm c eq)
(a: c)
(s: SB.seq c)
(r: SB.seq c {SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a (SP.foldm_snoc add s)) `eq.eq` (SP.foldm_snoc add r)) | val foldm_snoc_distributivity_left_eq
(#c #eq: _)
(mul add: CE.cm c eq)
(a: c)
(s: SB.seq c)
(r: SB.seq c {SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a (SP.foldm_snoc add s)) `eq.eq` (SP.foldm_snoc add r)) | let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 46,
"end_line": 584,
"start_col": 0,
"start_line": 578
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_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"
} | false |
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
a: c ->
s: FStar.Seq.Base.seq c ->
r: FStar.Seq.Base.seq c {FStar.Seq.Base.equal r (FStar.Matrix.const_op_seq mul a s)}
-> FStar.Pervasives.Lemma
(requires
FStar.Matrix.is_fully_distributive mul add /\ FStar.Matrix.is_absorber (CM?.unit add) mul)
(ensures
EQ?.eq eq
(CM?.mult mul a (FStar.Seq.Permutation.foldm_snoc add s))
(FStar.Seq.Permutation.foldm_snoc add r)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.equal",
"FStar.Matrix.const_op_seq",
"FStar.Matrix.foldm_snoc_distributivity_left",
"Prims.unit",
"Prims.l_and",
"FStar.Matrix.is_fully_distributive",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Seq.Permutation.foldm_snoc",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let foldm_snoc_distributivity_left_eq
#c
#eq
(mul: CE.cm c eq)
(add: CE.cm c eq)
(a: c)
(s: SB.seq c)
(r: SB.seq c {SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a (SP.foldm_snoc add s)) `eq.eq` (SP.foldm_snoc add r)) =
| foldm_snoc_distributivity_left mul add a s | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.