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.Seq.Properties.fst | FStar.Seq.Properties.split_5 | val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s))))) | val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s))))) | let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 81,
"end_line": 156,
"start_col": 0,
"start_line": 150
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> i: Prims.nat -> j: Prims.nat{i < j && j < FStar.Seq.Base.length s}
-> Prims.Pure (FStar.Seq.Base.seq (FStar.Seq.Base.seq a)) | Prims.Pure | [] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"FStar.Seq.Base.upd",
"FStar.Seq.Base.create",
"FStar.Seq.Base.slice",
"Prims.op_Addition"
] | [] | false | false | false | false | false | let split_5 #a s i j =
| let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.swap_frame_lo | val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i)) | val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i)) | let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 84,
"end_line": 260,
"start_col": 0,
"start_line": 260
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s: FStar.Seq.Base.seq a ->
lo: Prims.nat ->
i: Prims.nat{lo <= i} ->
j: Prims.nat{i <= j && j < FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice s lo i == FStar.Seq.Base.slice (FStar.Seq.Properties.swap s i j) lo i) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"FStar.Seq.Properties.swap",
"Prims.unit"
] | [] | true | false | true | false | false | let swap_frame_lo #_ s lo i j =
| cut (equal (slice s lo i) (slice (swap s i j) lo i)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_ordering_lo_snoc | val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv))) | val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv))) | let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 55,
"end_line": 254,
"start_col": 0,
"start_line": 252
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
f: FStar.Seq.Properties.tot_ord a ->
s: FStar.Seq.Base.seq a ->
i: Prims.nat ->
j: Prims.nat{i <= j && j < FStar.Seq.Base.length s} ->
pv: a
-> FStar.Pervasives.Lemma
(requires
(forall (y: a). FStar.Seq.Properties.mem y (FStar.Seq.Base.slice s i j) ==> f y pv) /\
f (FStar.Seq.Base.index s j) pv)
(ensures
forall (y: a). FStar.Seq.Properties.mem y (FStar.Seq.Base.slice s i (j + 1)) ==> f y pv) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Properties.tot_ord",
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.lemma_mem_append",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.create",
"FStar.Seq.Base.index",
"Prims.unit",
"Prims.cut",
"FStar.Seq.Base.equal",
"Prims.op_Addition",
"FStar.Seq.Base.append"
] | [] | true | false | true | false | false | let lemma_ordering_lo_snoc #_ f s i j pv =
| cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.swap_frame_lo' | val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i')) | val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i')) | let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i')) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 90,
"end_line": 262,
"start_col": 0,
"start_line": 262
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s: FStar.Seq.Base.seq a ->
lo: Prims.nat ->
i': Prims.nat{lo <= i'} ->
i: Prims.nat{i' <= i} ->
j: Prims.nat{i <= j && j < FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice s lo i' == FStar.Seq.Base.slice (FStar.Seq.Properties.swap s i j) lo i') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"FStar.Seq.Properties.swap",
"Prims.unit"
] | [] | true | false | true | false | false | let swap_frame_lo' #_ s lo i' i j =
| cut (equal (slice s lo i') (slice (swap s i j) lo i')) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_swap_slice_commute | val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start)))) | val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start)))) | let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start))) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 95,
"end_line": 267,
"start_col": 0,
"start_line": 266
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s: FStar.Seq.Base.seq a ->
start: Prims.nat ->
i: Prims.nat{start <= i} ->
j: Prims.nat{i <= j} ->
len: Prims.nat{j < len && len <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (FStar.Seq.Properties.swap s i j) start len ==
FStar.Seq.Properties.swap (FStar.Seq.Base.slice s start len) (i - start) (j - start)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"FStar.Seq.Properties.swap",
"Prims.op_Subtraction",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_swap_slice_commute #_ s start i j len =
| cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start))) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_swap_permutes_aux_frag_eq | val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1))) | val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1))) | let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1))) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 161,
"start_col": 0,
"start_line": 158
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s: FStar.Seq.Base.seq a ->
i: Prims.nat{i < FStar.Seq.Base.length s} ->
j: Prims.nat{i <= j && j < FStar.Seq.Base.length s} ->
i': Prims.nat ->
j':
Prims.nat
{i' <= j' /\ j' <= FStar.Seq.Base.length s /\ (j < i' \/ j' <= i \/ i < i' /\ j' <= j)}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice s i' j' == FStar.Seq.Base.slice (FStar.Seq.Properties.swap s i j) i' j' /\
FStar.Seq.Base.slice s i (i + 1) ==
FStar.Seq.Base.slice (FStar.Seq.Properties.swap s i j) j (j + 1) /\
FStar.Seq.Base.slice s j (j + 1) ==
FStar.Seq.Base.slice (FStar.Seq.Properties.swap s i j) i (i + 1)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.l_and",
"Prims.l_or",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"FStar.Seq.Properties.swap",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
| cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1))) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_slice_cons | val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j)))) | val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j)))) | let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 61,
"end_line": 246,
"start_col": 0,
"start_line": 244
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> i: Prims.nat -> j: Prims.nat{i < j && j <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
forall (x: a).
FStar.Seq.Properties.mem x (FStar.Seq.Base.slice s i j) <==>
x = FStar.Seq.Base.index s i ||
FStar.Seq.Properties.mem x (FStar.Seq.Base.slice s (i + 1) j)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.lemma_mem_append",
"FStar.Seq.Base.create",
"FStar.Seq.Base.index",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.unit",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.append"
] | [] | true | false | true | false | false | let lemma_slice_cons #_ s i j =
| cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.splice_refl | val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j)) | val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j)) | let splice_refl #_ s i j = cut (equal s (splice s i s j)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 273,
"start_col": 0,
"start_line": 273
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> i: Prims.nat -> j: Prims.nat{i <= j && j <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma (ensures s == FStar.Seq.Properties.splice s i s j) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Properties.splice",
"Prims.unit"
] | [] | true | false | true | false | false | let splice_refl #_ s i j =
| cut (equal s (splice s i s j)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_slice_snoc | val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1))))) | val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1))))) | let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1))) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 67,
"end_line": 250,
"start_col": 0,
"start_line": 248
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> i: Prims.nat -> j: Prims.nat{i < j && j <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
forall (x: a).
FStar.Seq.Properties.mem x (FStar.Seq.Base.slice s i j) <==>
x = FStar.Seq.Base.index s (j - 1) ||
FStar.Seq.Properties.mem x (FStar.Seq.Base.slice s i (j - 1))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.lemma_mem_append",
"FStar.Seq.Base.slice",
"Prims.op_Subtraction",
"FStar.Seq.Base.create",
"FStar.Seq.Base.index",
"Prims.unit",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.append"
] | [] | true | false | true | false | false | let lemma_slice_snoc #_ s i j =
| cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1))) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.swap_frame_hi | val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi)) | val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi)) | let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 86,
"end_line": 264,
"start_col": 0,
"start_line": 264
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i')) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s: FStar.Seq.Base.seq a ->
i: Prims.nat ->
j: Prims.nat{i <= j} ->
k: Prims.nat{j < k} ->
hi: Prims.nat{k <= hi /\ hi <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice s k hi == FStar.Seq.Base.slice (FStar.Seq.Properties.swap s i j) k hi) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.l_and",
"FStar.Seq.Base.length",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"FStar.Seq.Properties.swap",
"Prims.unit"
] | [] | true | false | true | false | false | let swap_frame_hi #_ s i j k hi =
| cut (equal (slice s k hi) (slice (swap s i j) k hi)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_swap_permutes_slice | val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len))) | val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len))) | let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 271,
"start_col": 0,
"start_line": 269
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s: FStar.Seq.Base.seq a ->
start: Prims.nat ->
i: Prims.nat{start <= i} ->
j: Prims.nat{i <= j} ->
len: Prims.nat{j < len && len <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Properties.permutation a
(FStar.Seq.Base.slice s start len)
(FStar.Seq.Base.slice (FStar.Seq.Properties.swap s i j) start len)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.lemma_swap_permutes",
"FStar.Seq.Base.slice",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.Seq.Properties.lemma_swap_slice_commute"
] | [] | true | false | true | false | false | let lemma_swap_permutes_slice #_ s start i j len =
| lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_seq_frame_hi | val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m))) | val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m))) | let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 278,
"start_col": 0,
"start_line": 277
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s1: FStar.Seq.Base.seq a ->
s2: FStar.Seq.Base.seq a {FStar.Seq.Base.length s1 = FStar.Seq.Base.length s2} ->
i: Prims.nat ->
j: Prims.nat{i <= j} ->
m: Prims.nat{j <= m} ->
n: Prims.nat{m < n && n <= FStar.Seq.Base.length s1}
-> FStar.Pervasives.Lemma (requires s1 == FStar.Seq.Properties.splice s2 i s1 j)
(ensures
FStar.Seq.Base.slice s1 m n == FStar.Seq.Base.slice s2 m n /\
FStar.Seq.Base.index s1 m == FStar.Seq.Base.index s2 m) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.op_LessThanOrEqual",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_seq_frame_hi #_ s1 s2 i j m n =
| cut (equal (slice s1 m n) (slice s2 m n)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_ordering_hi_cons | val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y))) | val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y))) | let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 69,
"end_line": 258,
"start_col": 0,
"start_line": 256
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
f: FStar.Seq.Properties.tot_ord a ->
s: FStar.Seq.Base.seq a ->
back: Prims.nat ->
len: Prims.nat{back < len && len <= FStar.Seq.Base.length s} ->
pv: a
-> FStar.Pervasives.Lemma
(requires
(forall (y: a).
FStar.Seq.Properties.mem y (FStar.Seq.Base.slice s (back + 1) len) ==> f pv y) /\
f pv (FStar.Seq.Base.index s back))
(ensures
forall (y: a). FStar.Seq.Properties.mem y (FStar.Seq.Base.slice s back len) ==> f pv y) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Properties.tot_ord",
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.lemma_mem_append",
"FStar.Seq.Base.create",
"FStar.Seq.Base.index",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.unit",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.append"
] | [] | true | false | true | false | false | let lemma_ordering_hi_cons #_ f s back len pv =
| cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_seq_frame_lo | val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j))) | val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j))) | let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 281,
"start_col": 0,
"start_line": 280
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s1: FStar.Seq.Base.seq a ->
s2: FStar.Seq.Base.seq a {FStar.Seq.Base.length s1 = FStar.Seq.Base.length s2} ->
i: Prims.nat ->
j: Prims.nat{i <= j} ->
m: Prims.nat{j < m} ->
n: Prims.nat{m <= n && n <= FStar.Seq.Base.length s1}
-> FStar.Pervasives.Lemma (requires s1 == FStar.Seq.Properties.splice s2 m s1 n)
(ensures
FStar.Seq.Base.slice s1 i j == FStar.Seq.Base.slice s2 i j /\
FStar.Seq.Base.index s1 j == FStar.Seq.Base.index s2 j) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_AmpAmp",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_seq_frame_lo #_ s1 s2 i j m n =
| cut (equal (slice s1 i j) (slice s2 i j)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_tail_slice | val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))] | val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))] | let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 284,
"start_col": 0,
"start_line": 283
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> i: Prims.nat -> j: Prims.nat{i < j && j <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Properties.tail (FStar.Seq.Base.slice s i j) == FStar.Seq.Base.slice s (i + 1) j)
[SMTPat (FStar.Seq.Properties.tail (FStar.Seq.Base.slice s i j))] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Properties.tail",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_tail_slice #_ s i j =
| cut (equal (tail (slice s i j)) (slice s (i + 1) j)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_swap_splice | val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len)) | val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len)) | let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 101,
"end_line": 275,
"start_col": 0,
"start_line": 275
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s: FStar.Seq.Base.seq a ->
start: Prims.nat ->
i: Prims.nat{start <= i} ->
j: Prims.nat{i <= j} ->
len: Prims.nat{j < len && len <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Properties.swap s i j ==
FStar.Seq.Properties.splice s start (FStar.Seq.Properties.swap s i j) len) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Properties.swap",
"FStar.Seq.Properties.splice",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_swap_splice #_ s start i j len =
| cut (equal (swap s i j) (splice s start (swap s i j) len)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_weaken_frame_left | val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k)) | val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k)) | let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 78,
"end_line": 288,
"start_col": 0,
"start_line": 288
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s1: FStar.Seq.Base.seq a ->
s2: FStar.Seq.Base.seq a {FStar.Seq.Base.length s1 = FStar.Seq.Base.length s2} ->
i: Prims.nat ->
j: Prims.nat ->
k: Prims.nat{i <= j && j <= k && k <= FStar.Seq.Base.length s1}
-> FStar.Pervasives.Lemma (requires s1 == FStar.Seq.Properties.splice s2 j s1 k)
(ensures s1 == FStar.Seq.Properties.splice s2 i s1 k) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Properties.splice",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_weaken_frame_left #_ s1 s2 i j k =
| cut (equal s1 (splice s2 i s1 k)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.perm_len' | val perm_len' (#a: eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1)) | val perm_len' (#a: eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1)) | let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 235,
"start_col": 0,
"start_line": 210
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma (requires FStar.Seq.Properties.permutation a s1 s2)
(ensures FStar.Seq.Base.length s1 == FStar.Seq.Base.length s2)
(decreases FStar.Seq.Base.length s1) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.bool",
"Prims._assert",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Properties.count",
"FStar.Seq.Base.index",
"Prims.unit",
"FStar.Seq.Properties.perm_len'",
"FStar.Seq.Properties.permutation",
"FStar.Seq.Properties.lemma_append_count",
"FStar.Seq.Properties.tail",
"FStar.Seq.Base.create",
"FStar.Seq.Base.append",
"FStar.Seq.Base.equal",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.split_eq",
"Prims.nat",
"FStar.Seq.Properties.index_mem",
"FStar.Seq.Properties.head",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec perm_len' (#a: eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1)) =
| if length s1 = 0
then if length s2 = 0 then () else assert (count (index s2 0) s2 > 0)
else
let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then
(assert (permutation a s1_tl s2_tl);
perm_len' s1_tl s2_tl)
else
let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2' | false |
Vale.Transformers.BoundedInstructionEffects.fst | Vale.Transformers.BoundedInstructionEffects.lemma_instr_write_outputs_only_writes | val lemma_instr_write_outputs_only_writes
(outs: list instr_out)
(args: list instr_operand)
(vs: instr_ret_t outs)
(oprs: instr_operands_t outs args)
(s_orig1 s1 s_orig2 s2: machine_state)
: Lemma
(requires
((unchanged_at (aux_read_set1 outs args oprs) s_orig1 s_orig2) /\
(unchanged_at' (aux_read_set1 outs args oprs) s1 s2) /\ (s1.ms_ok = s2.ms_ok)))
(ensures
(let s1', s2' =
instr_write_outputs outs args vs oprs s_orig1 s1,
instr_write_outputs outs args vs oprs s_orig2 s2
in
let locs = aux_write_set outs args oprs in
(unchanged_at' locs s1' s2' /\ unchanged_except locs s1 s1' /\
unchanged_except locs s2 s2' /\ (not s1.ms_ok ==> not s1'.ms_ok) /\
(not s2.ms_ok ==> not s2'.ms_ok)))) | val lemma_instr_write_outputs_only_writes
(outs: list instr_out)
(args: list instr_operand)
(vs: instr_ret_t outs)
(oprs: instr_operands_t outs args)
(s_orig1 s1 s_orig2 s2: machine_state)
: Lemma
(requires
((unchanged_at (aux_read_set1 outs args oprs) s_orig1 s_orig2) /\
(unchanged_at' (aux_read_set1 outs args oprs) s1 s2) /\ (s1.ms_ok = s2.ms_ok)))
(ensures
(let s1', s2' =
instr_write_outputs outs args vs oprs s_orig1 s1,
instr_write_outputs outs args vs oprs s_orig2 s2
in
let locs = aux_write_set outs args oprs in
(unchanged_at' locs s1' s2' /\ unchanged_except locs s1 s1' /\
unchanged_except locs s2 s2' /\ (not s1.ms_ok ==> not s1'.ms_ok) /\
(not s2.ms_ok ==> not s2'.ms_ok)))) | let rec lemma_instr_write_outputs_only_writes
(outs:list instr_out) (args:list instr_operand)
(vs:instr_ret_t outs) (oprs:instr_operands_t outs args)
(s_orig1 s1 s_orig2 s2:machine_state) :
Lemma
(requires (
(unchanged_at (aux_read_set1 outs args oprs) s_orig1 s_orig2) /\
(unchanged_at' (aux_read_set1 outs args oprs) s1 s2) /\
(s1.ms_ok = s2.ms_ok)))
(ensures (
let s1', s2' =
instr_write_outputs outs args vs oprs s_orig1 s1,
instr_write_outputs outs args vs oprs s_orig2 s2 in
let locs = aux_write_set outs args oprs in
(unchanged_at' locs s1' s2' /\
unchanged_except locs s1 s1' /\
unchanged_except locs s2 s2' /\
(not s1.ms_ok ==> not s1'.ms_ok) /\
(not s2.ms_ok ==> not s2'.ms_ok)))) =
let s1', s2' =
instr_write_outputs outs args vs oprs s_orig1 s1,
instr_write_outputs outs args vs oprs s_orig2 s2 in
match outs with
| [] -> ()
| (io, i) :: outs -> (
let ((v:instr_val_t i), (vs:instr_ret_t outs)) =
match outs with
| [] -> (vs, ())
| _::_ -> let vs = coerce vs in (fst vs, snd vs)
in
match i with
| IOpEx i ->
let o, oprs = coerce oprs in
let loc_op_l, loc_op_r = locations_of_explicit i o in
let loc_op_b = loc_op_l `L.append` loc_op_r in
let loc_rest = aux_read_set1 outs args oprs in
lemma_unchanged_at_append loc_op_l loc_op_r s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_l loc_rest s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_b loc_rest s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_l loc_rest s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_l loc_op_r s1 s2;
lemma_unchanged_at_append loc_op_l loc_rest s1 s2;
lemma_unchanged_at_append loc_op_b loc_rest s1 s2;
lemma_unchanged_at_append loc_op_l loc_rest s1 s2;
lemma_instr_write_output_explicit_only_writes i v o s_orig1 s1 s_orig2 s2;
let s1_old, s1 = s1, instr_write_output_explicit i v o s_orig1 s1 in
let s2_old, s2 = s2, instr_write_output_explicit i v o s_orig2 s2 in
lemma_unchanged_at'_maintained loc_rest loc_op_r s1_old s1 s2_old s2;
lemma_instr_write_outputs_only_writes outs args vs oprs s_orig1 s1 s_orig2 s2;
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig1 s1 loc_op_r;
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig2 s2 loc_op_r;
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig1 s1 [];
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig2 s2 [];
let s1_old, s1 = s1, instr_write_outputs outs args vs oprs s_orig1 s1 in
let s2_old, s2 = s2, instr_write_outputs outs args vs oprs s_orig2 s2 in
lemma_unchanged_at_append loc_op_r (aux_write_set outs args oprs) s1 s2;
lemma_unchanged_at'_maintained loc_op_r (aux_write_set outs args oprs) s1_old s1 s2_old s2
| IOpIm i ->
let oprs = coerce oprs in
let loc_op_l, loc_op_r = locations_of_implicit i in
let loc_op_b = loc_op_l `L.append` loc_op_r in
let loc_rest = aux_read_set1 outs args oprs in
lemma_unchanged_at_append loc_op_l loc_op_r s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_l loc_rest s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_b loc_rest s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_l loc_rest s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_l loc_op_r s1 s2;
lemma_unchanged_at_append loc_op_l loc_rest s1 s2;
lemma_unchanged_at_append loc_op_b loc_rest s1 s2;
lemma_unchanged_at_append loc_op_l loc_rest s1 s2;
lemma_instr_write_output_implicit_only_writes i v s_orig1 s1 s_orig2 s2;
let s1_old, s1 = s1, instr_write_output_implicit i v s_orig1 s1 in
let s2_old, s2 = s2, instr_write_output_implicit i v s_orig2 s2 in
lemma_unchanged_at'_maintained loc_rest loc_op_r s1_old s1 s2_old s2;
lemma_instr_write_outputs_only_writes outs args vs oprs s_orig1 s1 s_orig2 s2;
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig1 s1 loc_op_r;
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig2 s2 loc_op_r;
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig1 s1 [];
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig2 s2 [];
let s1_old, s1 = s1, instr_write_outputs outs args vs oprs s_orig1 s1 in
let s2_old, s2 = s2, instr_write_outputs outs args vs oprs s_orig2 s2 in
lemma_unchanged_at_append loc_op_r (aux_write_set outs args oprs) s1 s2;
lemma_unchanged_at'_maintained loc_op_r (aux_write_set outs args oprs) s1_old s1 s2_old s2
) | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.BoundedInstructionEffects.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 572,
"start_col": 0,
"start_line": 489
} | module Vale.Transformers.BoundedInstructionEffects
open Vale.X64.Bytes_Code_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Machine_s
open Vale.X64.Print_s
open Vale.Def.PossiblyMonad
open Vale.Transformers.Locations
friend Vale.Transformers.Locations
module L = FStar.List.Tot
let locations_of_maddr (m:maddr) (mem:location) : locations =
mem :: (
match m with
| MConst _ -> []
| MReg r _ -> [ALocReg r]
| MIndex b _ i _ -> [ALocReg b; ALocReg i]
)
let locations_of_operand64 (o:operand64) : locations & locations =
match o with
| OConst _ -> [], []
| OReg r -> [], [ALocReg (Reg 0 r)]
| OMem (m, _) -> locations_of_maddr m ALocMem, [ALocMem]
| OStack (m, _) -> (ALocReg (Reg 0 rRsp)) :: locations_of_maddr m ALocStack, [ALocStack]
let locations_of_operand128 (o:operand128) : locations & locations =
match o with
| OConst _ -> [], []
| OReg r -> [], [ALocReg (Reg 1 r)]
| OMem (m, _) -> locations_of_maddr m ALocMem, [ALocMem]
| OStack (m, _) -> (ALocReg (Reg 0 rRsp)) :: locations_of_maddr m ALocStack, [ALocStack]
let locations_of_explicit (t:instr_operand_explicit) (i:instr_operand_t t) : locations & locations =
match t with
| IOp64 -> locations_of_operand64 i
| IOpXmm -> locations_of_operand128 i
let locations_of_implicit (t:instr_operand_implicit) : locations & locations =
match t with
| IOp64One i -> locations_of_operand64 i
| IOpXmmOne i -> locations_of_operand128 i
| IOpFlagsCf -> [], [ALocCf]
| IOpFlagsOf -> [], [ALocOf]
let both (x: locations & locations) =
let a, b = x in
a `L.append` b
let rec aux_read_set0 (args:list instr_operand) (oprs:instr_operands_t_args args) : locations =
match args with
| [] -> []
| (IOpEx i) :: args ->
let l, r = coerce #(instr_operand_t i & instr_operands_t_args args) oprs in
both (locations_of_explicit i l) `L.append` aux_read_set0 args r
| (IOpIm i) :: args ->
both (locations_of_implicit i) `L.append` aux_read_set0 args (coerce #(instr_operands_t_args args) oprs)
let rec aux_read_set1
(outs:list instr_out) (args:list instr_operand) (oprs:instr_operands_t outs args) : locations =
match outs with
| [] -> aux_read_set0 args oprs
| (Out, IOpEx i) :: outs ->
let l, r = coerce #(instr_operand_t i & instr_operands_t outs args) oprs in
fst (locations_of_explicit i l) `L.append` aux_read_set1 outs args r
| (InOut, IOpEx i) :: outs ->
let l, r = coerce #(instr_operand_t i & instr_operands_t outs args) oprs in
both (locations_of_explicit i l) `L.append` aux_read_set1 outs args r
| (Out, IOpIm i) :: outs ->
fst (locations_of_implicit i) `L.append` aux_read_set1 outs args (coerce #(instr_operands_t outs args) oprs)
| (InOut, IOpIm i) :: outs ->
both (locations_of_implicit i) `L.append` aux_read_set1 outs args (coerce #(instr_operands_t outs args) oprs)
let read_set (i:instr_t_record) (oprs:instr_operands_t i.outs i.args) : locations =
aux_read_set1 i.outs i.args oprs
let rec aux_write_set
(outs:list instr_out) (args:list instr_operand) (oprs:instr_operands_t outs args) : locations =
match outs with
| [] -> []
| (_, IOpEx i) :: outs ->
let l, r = coerce #(instr_operand_t i & instr_operands_t outs args) oprs in
snd (locations_of_explicit i l) `L.append` aux_write_set outs args r
| (_, IOpIm i) :: outs ->
snd (locations_of_implicit i) `L.append` aux_write_set outs args (coerce #(instr_operands_t outs args) oprs)
let write_set (i:instr_t_record) (oprs:instr_operands_t i.outs i.args) : list location =
let InstrTypeRecord #outs #args #havoc_flags _ = i in
let ws = aux_write_set outs args oprs in
match havoc_flags with
| HavocFlags -> ALocCf :: ALocOf :: ws
| PreserveFlags -> ws
let constant_writes (i:instr_t_record) (oprs:instr_operands_t i.outs i.args) : locations_with_values =
let InstrTypeRecord #outs #args #havoc_flags _ = i in
match havoc_flags with
| HavocFlags -> (
let ws = aux_write_set outs args oprs in
let cr = [] in
let cr = if L.mem ALocCf ws then cr else (| ALocCf, None |) :: cr in
let cr = if L.mem ALocOf ws then cr else (| ALocOf, None |) :: cr in
cr
)
| PreserveFlags -> []
(* See fsti *)
let rw_set_of_ins i =
match i with
| Instr i oprs _ ->
{
loc_reads = read_set i oprs;
loc_writes = write_set i oprs;
loc_constant_writes = constant_writes i oprs;
}
| Push src t ->
{
loc_reads = ALocReg (Reg 0 rRsp) :: ALocStack :: both (locations_of_operand64 src);
loc_writes = [ALocReg (Reg 0 rRsp); ALocStack];
loc_constant_writes = [];
}
| Pop dst t ->
{
loc_reads = ALocReg (Reg 0 rRsp) :: ALocStack :: fst (locations_of_operand64 dst);
loc_writes = ALocReg (Reg 0 rRsp) :: snd (locations_of_operand64 dst);
loc_constant_writes = [];
}
| Alloc _ ->
{
loc_reads = [ALocReg (Reg 0 rRsp)];
loc_writes = [ALocReg (Reg 0 rRsp)];
loc_constant_writes = [];
}
| Dealloc _ ->
{
loc_reads = [ALocStack; ALocReg (Reg 0 rRsp)];
loc_writes = [ALocStack; ALocReg (Reg 0 rRsp)];
loc_constant_writes = [];
}
(* See fsti *)
let locations_of_ocmp o =
match o with
| OEq o1 o2
| ONe o1 o2
| OLe o1 o2
| OGe o1 o2
| OLt o1 o2
| OGt o1 o2 ->
both (locations_of_operand64 o1) `L.append` both (locations_of_operand64 o2)
#push-options "--z3rlimit 50 --initial_fuel 2 --max_fuel 2 --initial_ifuel 1 --max_ifuel 1"
#restart-solver
let rec lemma_instr_write_outputs_only_affects_write
(outs:list instr_out) (args:list instr_operand)
(vs:instr_ret_t outs) (oprs:instr_operands_t outs args) (s_orig s:machine_state)
(a:location) :
Lemma
(requires (
let w = aux_write_set outs args oprs in
!!(disjoint_location_from_locations a w)))
(ensures (
(eval_location a s == eval_location a (instr_write_outputs outs args vs oprs s_orig s)))) =
match outs with
| [] -> ()
| (_, i) :: outs -> (
let ((v:instr_val_t i), (vs:instr_ret_t outs)) =
match outs with
| [] -> (vs, ())
| _::_ -> let vs = coerce vs in (fst vs, snd vs)
in
match i with
| IOpEx i ->
let oprs = coerce oprs in
let s = instr_write_output_explicit i v (fst oprs) s_orig s in
lemma_instr_write_outputs_only_affects_write outs args vs (snd oprs) s_orig s a
| IOpIm i ->
let s = instr_write_output_implicit i v s_orig s in
lemma_instr_write_outputs_only_affects_write outs args vs (coerce oprs) s_orig s a
)
#pop-options
#push-options "--initial_fuel 2 --max_fuel 2 --initial_ifuel 1 --max_ifuel 1"
let lemma_eval_instr_only_affects_write
(it:instr_t_record) (oprs:instr_operands_t it.outs it.args) (ann:instr_annotation it)
(s0:machine_state)
(a:location) :
Lemma
(requires (
(let w = (rw_set_of_ins (Instr it oprs ann)).loc_writes in
!!(disjoint_location_from_locations a w) /\
(Some? (eval_instr it oprs ann s0)))))
(ensures (
(eval_location a s0 == eval_location a (Some?.v (eval_instr it oprs ann s0))))) =
let InstrTypeRecord #outs #args #havoc_flags' i = it in
let vs = instr_apply_eval outs args (instr_eval i) oprs s0 in
let s1 =
match havoc_flags' with
| HavocFlags -> {s0 with ms_flags = havoc_flags}
| PreserveFlags -> s0
in
let Some vs = vs in
let _ = instr_write_outputs outs args vs oprs s0 s1 in
lemma_instr_write_outputs_only_affects_write outs args vs oprs s0 s1 a
#pop-options
let lemma_machine_eval_ins_st_only_affects_write_aux (i:ins{Instr? i}) (s:machine_state) (a:location) :
Lemma
(requires (
let w = (rw_set_of_ins i).loc_writes in
(!!(disjoint_location_from_locations a w))))
(ensures (
(eval_location a s == eval_location a (run (machine_eval_ins_st i) s)))) =
let Instr it oprs ann = i in
match eval_instr it oprs ann s with
| Some _ -> lemma_eval_instr_only_affects_write it oprs ann s a
| None -> ()
let lemma_machine_eval_ins_st_only_affects_write (i:ins{Instr? i}) (s:machine_state) :
Lemma
(ensures (
(let w = (rw_set_of_ins i).loc_writes in
(unchanged_except w s (run (machine_eval_ins_st i) s))))) =
FStar.Classical.forall_intro (
FStar.Classical.move_requires (lemma_machine_eval_ins_st_only_affects_write_aux i s))
#push-options "--initial_fuel 4 --max_fuel 4 --initial_ifuel 2 --max_ifuel 2"
let lemma_instr_eval_operand_explicit_same_read_both
(i:instr_operand_explicit) (o:instr_operand_t i)
(s1 s2:machine_state) :
Lemma
(requires (
(unchanged_at (both (locations_of_explicit i o)) s1 s2)))
(ensures (
(instr_eval_operand_explicit i o s1) ==
(instr_eval_operand_explicit i o s2))) = ()
#pop-options
#push-options "--initial_fuel 4 --max_fuel 4 --initial_ifuel 2 --max_ifuel 2"
let lemma_instr_eval_operand_implicit_same_read_both
(i:instr_operand_implicit)
(s1 s2:machine_state) :
Lemma
(requires (
(unchanged_at (both (locations_of_implicit i)) s1 s2)))
(ensures (
(instr_eval_operand_implicit i s1) ==
(instr_eval_operand_implicit i s2))) = ()
#pop-options
let rec lemma_unchanged_at_append (l1 l2:locations) (s1 s2:machine_state) :
Lemma
(ensures (
(unchanged_at (l1 `L.append` l2) s1 s2) <==>
(unchanged_at l1 s1 s2 /\ unchanged_at l2 s1 s2))) =
match l1 with
| [] -> ()
| x :: xs ->
lemma_unchanged_at_append xs l2 s1 s2
let rec lemma_instr_apply_eval_args_same_read
(outs:list instr_out) (args:list instr_operand)
(f:instr_args_t outs args) (oprs:instr_operands_t_args args)
(s1 s2:machine_state) :
Lemma
(requires (unchanged_at (aux_read_set0 args oprs) s1 s2))
(ensures (
(instr_apply_eval_args outs args f oprs s1) ==
(instr_apply_eval_args outs args f oprs s2))) =
match args with
| [] -> ()
| i :: args ->
let (v1, v2, oprs) : option _ & option _ & instr_operands_t_args args =
match i with
| IOpEx i ->
let oprs = coerce oprs in
lemma_unchanged_at_append (both (locations_of_explicit i (fst oprs))) (aux_read_set0 args (snd oprs)) s1 s2;
lemma_instr_eval_operand_explicit_same_read_both i (fst oprs) s1 s2;
(instr_eval_operand_explicit i (fst oprs) s1,
instr_eval_operand_explicit i (fst oprs) s2,
snd oprs)
| IOpIm i ->
let oprs = coerce oprs in
lemma_unchanged_at_append (both (locations_of_implicit i)) (aux_read_set0 args oprs) s1 s2;
lemma_instr_eval_operand_implicit_same_read_both i s1 s2;
(instr_eval_operand_implicit i s1,
instr_eval_operand_implicit i s2,
coerce oprs)
in
assert (v1 == v2);
let f:arrow (instr_val_t i) (instr_args_t outs args) = coerce f in
let _ = bind_option v1 (fun v -> instr_apply_eval_args outs args (f v) oprs s1) in
let _ = bind_option v2 (fun v -> instr_apply_eval_args outs args (f v) oprs s2) in
match v1 with
| None -> ()
| Some v ->
lemma_instr_apply_eval_args_same_read outs args (f v) oprs s1 s2
#push-options "--z3rlimit 25 --initial_fuel 6 --max_fuel 6 --initial_ifuel 2 --max_ifuel 2"
let rec lemma_instr_apply_eval_inouts_same_read
(outs inouts:list instr_out) (args:list instr_operand)
(f:instr_inouts_t outs inouts args) (oprs:instr_operands_t inouts args)
(s1 s2:machine_state) :
Lemma
(requires (unchanged_at (aux_read_set1 inouts args oprs) s1 s2))
(ensures (
(instr_apply_eval_inouts outs inouts args f oprs s1) ==
(instr_apply_eval_inouts outs inouts args f oprs s2))) =
match inouts with
| [] ->
lemma_instr_apply_eval_args_same_read outs args f oprs s1 s2
| (Out, i)::inouts ->
let oprs =
match i with
| IOpEx i -> snd #(instr_operand_t i) (coerce oprs)
| IOpIm i -> coerce oprs
in
lemma_instr_apply_eval_inouts_same_read outs inouts args (coerce f) oprs s1 s2
| (InOut, i)::inouts ->
let (v1, v2, oprs) : option _ & option _ & instr_operands_t inouts args =
match i with
| IOpEx i ->
let oprs = coerce oprs in
lemma_unchanged_at_append (both (locations_of_explicit i (fst oprs))) (aux_read_set1 inouts args (snd oprs)) s1 s2;
lemma_instr_eval_operand_explicit_same_read_both i (fst oprs) s1 s2;
(instr_eval_operand_explicit i (fst oprs) s1,
instr_eval_operand_explicit i (fst oprs) s2,
snd oprs)
| IOpIm i ->
lemma_instr_eval_operand_implicit_same_read_both i s1 s2;
(instr_eval_operand_implicit i s1,
instr_eval_operand_implicit i s2,
coerce oprs)
in
assert (v1 == v2);
let f:arrow (instr_val_t i) (instr_inouts_t outs inouts args) = coerce f in
let _ = bind_option v1 (fun v -> instr_apply_eval_inouts outs inouts args (f v) oprs s1) in
let _ = bind_option v2 (fun v -> instr_apply_eval_inouts outs inouts args (f v) oprs s2) in
match v1 with
| None -> ()
| Some v ->
lemma_instr_apply_eval_inouts_same_read outs inouts args (f v) oprs s1 s2
#pop-options
let lemma_instr_apply_eval_same_read
(outs:list instr_out) (args:list instr_operand)
(f:instr_eval_t outs args) (oprs:instr_operands_t outs args)
(s1 s2:machine_state) :
Lemma
(requires (unchanged_at (aux_read_set1 outs args oprs) s1 s2))
(ensures (
(instr_apply_eval outs args f oprs s1) ==
(instr_apply_eval outs args f oprs s2))) =
lemma_instr_apply_eval_inouts_same_read outs outs args f oprs s1 s2
let unchanged_at' (l:locations) (s1 s2:machine_state) =
(s1.ms_ok = s2.ms_ok) /\
(s1.ms_ok /\ s2.ms_ok ==>
unchanged_at l s1 s2)
#push-options "--z3rlimit 20 --initial_fuel 4 --max_fuel 4 --initial_ifuel 3 --max_ifuel 3"
let lemma_instr_write_output_explicit_only_writes
(i:instr_operand_explicit) (v:instr_val_t (IOpEx i)) (o:instr_operand_t i)
(s_orig1 s1 s_orig2 s2:machine_state) :
Lemma
(requires (
(unchanged_at (fst (locations_of_explicit i o)) s_orig1 s_orig2) /\
(unchanged_at' (fst (locations_of_explicit i o)) s1 s2)))
(ensures (
let s1', s2' =
instr_write_output_explicit i v o s_orig1 s1,
instr_write_output_explicit i v o s_orig2 s2 in
let locs = snd (locations_of_explicit i o) in
(unchanged_at' locs s1' s2' /\
unchanged_except locs s1 s1' /\
unchanged_except locs s2 s2'))) = ()
#pop-options
#push-options "--z3rlimit 20 --initial_fuel 4 --max_fuel 4 --initial_ifuel 4 --max_ifuel 4"
let lemma_instr_write_output_implicit_only_writes
(i:instr_operand_implicit) (v:instr_val_t (IOpIm i))
(s_orig1 s1 s_orig2 s2:machine_state) :
Lemma
(requires (
(unchanged_at (fst (locations_of_implicit i)) s_orig1 s_orig2) /\
(unchanged_at' (fst (locations_of_implicit i)) s1 s2)))
(ensures (
let s1', s2' =
instr_write_output_implicit i v s_orig1 s1,
instr_write_output_implicit i v s_orig2 s2 in
let locs = snd (locations_of_implicit i) in
(unchanged_at' locs s1' s2' /\
unchanged_except locs s1 s1' /\
unchanged_except locs s2 s2'))) = ()
#pop-options
#push-options "--initial_fuel 2 --max_fuel 2 --initial_ifuel 1 --max_ifuel 1"
let rec lemma_unchanged_at'_mem (as0:locations) (a:location) (s1 s2:machine_state) :
Lemma
(requires (
(unchanged_at' as0 s1 s2) /\
(L.mem a as0)))
(ensures (
(eval_location a s1 == eval_location a s2 \/ not s1.ms_ok))) =
match as0 with
| [_] -> ()
| x :: xs ->
if a = x then () else
lemma_unchanged_at'_mem xs a s1 s2
#pop-options
let rec lemma_unchanged_except_not_mem (as0:locations) (a:location) :
Lemma
(requires (
(not (L.mem a as0))))
(ensures (
!!(disjoint_location_from_locations a as0))) =
match as0 with
| [] -> ()
| x :: xs -> lemma_unchanged_except_not_mem xs a
let rec lemma_unchanged_at'_maintained (locs locs_change:locations) (s1 s1' s2 s2':machine_state) :
Lemma
(requires (
(not s1.ms_ok ==> not s1'.ms_ok) /\
(not s2.ms_ok ==> not s2'.ms_ok) /\
(unchanged_at' locs s1 s2) /\
(unchanged_except locs_change s1 s1') /\
(unchanged_except locs_change s2 s2') /\
(unchanged_at' locs_change s1' s2')))
(ensures (
(unchanged_at' locs s1' s2'))) =
match locs with
| [] -> ()
| x :: xs ->
lemma_unchanged_at'_maintained xs locs_change s1 s1' s2 s2';
if x `L.mem` locs_change then (
lemma_unchanged_at'_mem locs_change x s1' s2'
) else (
lemma_unchanged_except_not_mem locs_change x
)
let rec lemma_disjoint_location_from_locations_append
(a:location) (as1 as2:list location) :
Lemma (
(!!(disjoint_location_from_locations a as1) /\
!!(disjoint_location_from_locations a as2)) <==>
(!!(disjoint_location_from_locations a (as1 `L.append` as2)))) =
match as1 with
| [] -> ()
| x :: xs ->
lemma_disjoint_location_from_locations_append a xs as2
let lemma_unchanged_except_extend (ls_extend ls:locations) (s1 s2:machine_state) :
Lemma
(requires (unchanged_except ls s1 s2))
(ensures (unchanged_except (ls_extend `L.append` ls) s1 s2)) =
let aux a :
Lemma
(requires (!!(disjoint_location_from_locations a (ls_extend `L.append` ls))))
(ensures (eval_location a s1 == eval_location a s2)) =
lemma_disjoint_location_from_locations_append a ls_extend ls
in
FStar.Classical.forall_intro (FStar.Classical.move_requires aux)
let lemma_instr_write_outputs_only_affects_write_extend
(outs:list instr_out) (args:list instr_operand)
(vs:instr_ret_t outs) (oprs:instr_operands_t outs args)
(s_orig s:machine_state)
(locs_extension:locations) :
Lemma
(ensures (
let s' = instr_write_outputs outs args vs oprs s_orig s in
let locs = aux_write_set outs args oprs in
unchanged_except (locs_extension `L.append` locs) s s')) =
let s' = instr_write_outputs outs args vs oprs s_orig s in
let locs = aux_write_set outs args oprs in
FStar.Classical.forall_intro
(FStar.Classical.move_requires (lemma_instr_write_outputs_only_affects_write outs args vs oprs s_orig s));
lemma_unchanged_except_extend locs_extension locs s s'
#restart-solver | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Transformers.Locations.fst.checked",
"Vale.Transformers.Locations.fst.checked",
"Vale.Def.PossiblyMonad.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Option.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Transformers.BoundedInstructionEffects.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.PossiblyMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.Locations",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.PossiblyMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"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": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 400,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
outs: Prims.list Vale.X64.Instruction_s.instr_out ->
args: Prims.list Vale.X64.Instruction_s.instr_operand ->
vs: Vale.X64.Instruction_s.instr_ret_t outs ->
oprs: Vale.X64.Instruction_s.instr_operands_t outs args ->
s_orig1: Vale.X64.Machine_Semantics_s.machine_state ->
s1: Vale.X64.Machine_Semantics_s.machine_state ->
s_orig2: Vale.X64.Machine_Semantics_s.machine_state ->
s2: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(requires
Vale.Transformers.BoundedInstructionEffects.unchanged_at (Vale.Transformers.BoundedInstructionEffects.aux_read_set1
outs
args
oprs)
s_orig1
s_orig2 /\
Vale.Transformers.BoundedInstructionEffects.unchanged_at' (Vale.Transformers.BoundedInstructionEffects.aux_read_set1
outs
args
oprs)
s1
s2 /\ Mkmachine_state?.ms_ok s1 = Mkmachine_state?.ms_ok s2)
(ensures
(let _ =
Vale.X64.Machine_Semantics_s.instr_write_outputs outs args vs oprs s_orig1 s1,
Vale.X64.Machine_Semantics_s.instr_write_outputs outs args vs oprs s_orig2 s2
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ s1' s2' = _ in
let locs = Vale.Transformers.BoundedInstructionEffects.aux_write_set outs args oprs in
Vale.Transformers.BoundedInstructionEffects.unchanged_at' locs s1' s2' /\
Vale.Transformers.BoundedInstructionEffects.unchanged_except locs s1 s1' /\
Vale.Transformers.BoundedInstructionEffects.unchanged_except locs s2 s2' /\
(Prims.op_Negation (Mkmachine_state?.ms_ok s1) ==>
Prims.op_Negation (Mkmachine_state?.ms_ok s1')) /\
(Prims.op_Negation (Mkmachine_state?.ms_ok s2) ==>
Prims.op_Negation (Mkmachine_state?.ms_ok s2')))
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.instr_ret_t",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Instruction_s.instr_operand_inout",
"Vale.X64.Instruction_s.instr_val_t",
"Vale.X64.Instruction_s.instr_operand_explicit",
"Vale.X64.Instruction_s.instr_operand_t",
"Vale.Transformers.Locations.locations",
"Prims.l_or",
"Prims.precedes",
"Prims.l_and",
"Prims.op_Equals_Equals_Equals",
"Vale.Transformers.BoundedInstructionEffects.lemma_unchanged_at'_maintained",
"Vale.Transformers.BoundedInstructionEffects.aux_write_set",
"Prims.unit",
"Vale.Transformers.BoundedInstructionEffects.lemma_unchanged_at_append",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Machine_Semantics_s.instr_write_outputs",
"Vale.Transformers.BoundedInstructionEffects.lemma_instr_write_outputs_only_affects_write_extend",
"Prims.Nil",
"Vale.Transformers.Locations.location",
"Vale.Transformers.BoundedInstructionEffects.lemma_instr_write_outputs_only_writes",
"Vale.X64.Machine_Semantics_s.instr_write_output_explicit",
"Vale.Transformers.BoundedInstructionEffects.lemma_instr_write_output_explicit_only_writes",
"Vale.Transformers.BoundedInstructionEffects.aux_read_set1",
"FStar.List.Tot.Base.append",
"Vale.Transformers.BoundedInstructionEffects.locations_of_explicit",
"Vale.X64.Instruction_s.coerce",
"Vale.X64.Instruction_s.instr_operand_implicit",
"Vale.X64.Machine_Semantics_s.instr_write_output_implicit",
"Vale.Transformers.BoundedInstructionEffects.lemma_instr_write_output_implicit_only_writes",
"Vale.Transformers.BoundedInstructionEffects.locations_of_implicit",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"Vale.Transformers.BoundedInstructionEffects.unchanged_at",
"Vale.Transformers.BoundedInstructionEffects.unchanged_at'",
"Prims.b2t",
"Prims.op_Equality",
"Prims.bool",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Prims.squash",
"Vale.Transformers.BoundedInstructionEffects.unchanged_except",
"Prims.l_imp",
"Prims.op_Negation",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_instr_write_outputs_only_writes
(outs: list instr_out)
(args: list instr_operand)
(vs: instr_ret_t outs)
(oprs: instr_operands_t outs args)
(s_orig1 s1 s_orig2 s2: machine_state)
: Lemma
(requires
((unchanged_at (aux_read_set1 outs args oprs) s_orig1 s_orig2) /\
(unchanged_at' (aux_read_set1 outs args oprs) s1 s2) /\ (s1.ms_ok = s2.ms_ok)))
(ensures
(let s1', s2' =
instr_write_outputs outs args vs oprs s_orig1 s1,
instr_write_outputs outs args vs oprs s_orig2 s2
in
let locs = aux_write_set outs args oprs in
(unchanged_at' locs s1' s2' /\ unchanged_except locs s1 s1' /\
unchanged_except locs s2 s2' /\ (not s1.ms_ok ==> not s1'.ms_ok) /\
(not s2.ms_ok ==> not s2'.ms_ok)))) =
| let s1', s2' =
instr_write_outputs outs args vs oprs s_orig1 s1, instr_write_outputs outs args vs oprs s_orig2 s2
in
match outs with
| [] -> ()
| (io, i) :: outs ->
(let (v: instr_val_t i), (vs: instr_ret_t outs) =
match outs with
| [] -> (vs, ())
| _ :: _ ->
let vs = coerce vs in
(fst vs, snd vs)
in
match i with
| IOpEx i ->
let o, oprs = coerce oprs in
let loc_op_l, loc_op_r = locations_of_explicit i o in
let loc_op_b = loc_op_l `L.append` loc_op_r in
let loc_rest = aux_read_set1 outs args oprs in
lemma_unchanged_at_append loc_op_l loc_op_r s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_l loc_rest s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_b loc_rest s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_l loc_rest s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_l loc_op_r s1 s2;
lemma_unchanged_at_append loc_op_l loc_rest s1 s2;
lemma_unchanged_at_append loc_op_b loc_rest s1 s2;
lemma_unchanged_at_append loc_op_l loc_rest s1 s2;
lemma_instr_write_output_explicit_only_writes i v o s_orig1 s1 s_orig2 s2;
let s1_old, s1 = s1, instr_write_output_explicit i v o s_orig1 s1 in
let s2_old, s2 = s2, instr_write_output_explicit i v o s_orig2 s2 in
lemma_unchanged_at'_maintained loc_rest loc_op_r s1_old s1 s2_old s2;
lemma_instr_write_outputs_only_writes outs args vs oprs s_orig1 s1 s_orig2 s2;
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig1 s1 loc_op_r;
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig2 s2 loc_op_r;
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig1 s1 [];
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig2 s2 [];
let s1_old, s1 = s1, instr_write_outputs outs args vs oprs s_orig1 s1 in
let s2_old, s2 = s2, instr_write_outputs outs args vs oprs s_orig2 s2 in
lemma_unchanged_at_append loc_op_r (aux_write_set outs args oprs) s1 s2;
lemma_unchanged_at'_maintained loc_op_r (aux_write_set outs args oprs) s1_old s1 s2_old s2
| IOpIm i ->
let oprs = coerce oprs in
let loc_op_l, loc_op_r = locations_of_implicit i in
let loc_op_b = loc_op_l `L.append` loc_op_r in
let loc_rest = aux_read_set1 outs args oprs in
lemma_unchanged_at_append loc_op_l loc_op_r s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_l loc_rest s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_b loc_rest s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_l loc_rest s_orig1 s_orig2;
lemma_unchanged_at_append loc_op_l loc_op_r s1 s2;
lemma_unchanged_at_append loc_op_l loc_rest s1 s2;
lemma_unchanged_at_append loc_op_b loc_rest s1 s2;
lemma_unchanged_at_append loc_op_l loc_rest s1 s2;
lemma_instr_write_output_implicit_only_writes i v s_orig1 s1 s_orig2 s2;
let s1_old, s1 = s1, instr_write_output_implicit i v s_orig1 s1 in
let s2_old, s2 = s2, instr_write_output_implicit i v s_orig2 s2 in
lemma_unchanged_at'_maintained loc_rest loc_op_r s1_old s1 s2_old s2;
lemma_instr_write_outputs_only_writes outs args vs oprs s_orig1 s1 s_orig2 s2;
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig1 s1 loc_op_r;
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig2 s2 loc_op_r;
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig1 s1 [];
lemma_instr_write_outputs_only_affects_write_extend outs args vs oprs s_orig2 s2 [];
let s1_old, s1 = s1, instr_write_outputs outs args vs oprs s_orig1 s1 in
let s2_old, s2 = s2, instr_write_outputs outs args vs oprs s_orig2 s2 in
lemma_unchanged_at_append loc_op_r (aux_write_set outs args oprs) s1 s2;
lemma_unchanged_at'_maintained loc_op_r (aux_write_set outs args oprs) s1_old s1 s2_old s2) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.seq_mem_k | val seq_mem_k: #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
[SMTPat (mem (Seq.index s n) s)] | val seq_mem_k: #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
[SMTPat (mem (Seq.index s n) s)] | let seq_mem_k = seq_mem_k' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 383,
"start_col": 0,
"start_line": 383
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> n: Prims.nat{n < FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma (ensures FStar.Seq.Properties.mem (FStar.Seq.Base.index s n) s)
[SMTPat (FStar.Seq.Properties.mem (FStar.Seq.Base.index s n) s)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Properties.seq_mem_k'"
] | [] | true | false | true | false | false | let seq_mem_k =
| seq_mem_k' | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_seq_list_bij | val lemma_seq_list_bij: #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s)) | val lemma_seq_list_bij: #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s)) | let lemma_seq_list_bij = lemma_seq_list_bij' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 407,
"start_col": 0,
"start_line": 407
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma (ensures FStar.Seq.Base.seq_of_list (FStar.Seq.Base.seq_to_list s) == s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Properties.lemma_seq_list_bij'"
] | [] | true | false | true | false | false | let lemma_seq_list_bij =
| lemma_seq_list_bij' | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.find_append_some | val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1)) | val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1)) | let find_append_some = find_append_some' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 333,
"start_col": 0,
"start_line": 333
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a -> f: (_: a -> Prims.bool)
-> FStar.Pervasives.Lemma (requires Some? (FStar.Seq.Properties.find_l f s1))
(ensures
FStar.Seq.Properties.find_l f (FStar.Seq.Base.append s1 s2) ==
FStar.Seq.Properties.find_l f s1) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Properties.find_append_some'"
] | [] | true | false | true | false | false | let find_append_some =
| find_append_some' | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_list_seq_bij | val lemma_list_seq_bij: #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l)) | val lemma_list_seq_bij: #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l)) | let lemma_list_seq_bij = lemma_list_seq_bij' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 421,
"start_col": 0,
"start_line": 421
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | l: Prims.list a
-> FStar.Pervasives.Lemma (ensures FStar.Seq.Base.seq_to_list (FStar.Seq.Base.seq_of_list l) == l) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Properties.lemma_list_seq_bij'"
] | [] | true | false | true | false | false | let lemma_list_seq_bij =
| lemma_list_seq_bij' | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_snoc_inj | val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2)) | val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2)) | let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 319,
"start_col": 0,
"start_line": 315
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a -> v1: a -> v2: a
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.equal (FStar.Seq.Properties.snoc s1 v1) (FStar.Seq.Properties.snoc s2 v2))
(ensures v1 == v2 /\ FStar.Seq.Base.equal s1 s2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims._assert",
"Prims.eq2",
"FStar.Seq.Properties.head",
"Prims.unit",
"FStar.Seq.Properties.lemma_append_inj",
"FStar.Seq.Base.create"
] | [] | true | false | true | false | false | let lemma_snoc_inj #_ s1 s2 v1 v2 =
| let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert (head t1 == head t2) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.contains | val contains (#a:Type) (s:seq a) (x:a) : Tot Type0 | val contains (#a:Type) (s:seq a) (x:a) : Tot Type0 | let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 437,
"start_col": 0,
"start_line": 436
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> x: a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.l_Exists",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.eq2",
"FStar.Seq.Base.index"
] | [] | false | false | false | true | true | let contains #a s x =
| exists (k: nat). k < Seq.length s /\ Seq.index s k == x | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_trans_frame | val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j)) | val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j)) | let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 73,
"end_line": 290,
"start_col": 0,
"start_line": 290
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s1: FStar.Seq.Base.seq a ->
s2: FStar.Seq.Base.seq a ->
s3:
FStar.Seq.Base.seq a
{ FStar.Seq.Base.length s1 = FStar.Seq.Base.length s2 /\
FStar.Seq.Base.length s2 = FStar.Seq.Base.length s3 } ->
i: Prims.nat ->
j: Prims.nat{i <= j && j <= FStar.Seq.Base.length s1}
-> FStar.Pervasives.Lemma
(requires
s1 == FStar.Seq.Properties.splice s2 i s1 j /\ s2 == FStar.Seq.Properties.splice s3 i s2 j)
(ensures s1 == FStar.Seq.Properties.splice s3 i s1 j) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Properties.splice",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_trans_frame #_ s1 s2 s3 i j =
| cut (equal s1 (splice s3 i s1 j)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_weaken_frame_right | val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k)) | val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k)) | let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 79,
"end_line": 286,
"start_col": 0,
"start_line": 286
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s1: FStar.Seq.Base.seq a ->
s2: FStar.Seq.Base.seq a {FStar.Seq.Base.length s1 = FStar.Seq.Base.length s2} ->
i: Prims.nat ->
j: Prims.nat ->
k: Prims.nat{i <= j && j <= k && k <= FStar.Seq.Base.length s1}
-> FStar.Pervasives.Lemma (requires s1 == FStar.Seq.Properties.splice s2 i s1 j)
(ensures s1 == FStar.Seq.Properties.splice s2 i s1 k) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Properties.splice",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_weaken_frame_right #_ s1 s2 i j k =
| cut (equal s1 (splice s2 i s1 k)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.find_append_none | val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2)) | val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2)) | let find_append_none = find_append_none' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 345,
"start_col": 0,
"start_line": 345
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a -> f: (_: a -> Prims.bool)
-> FStar.Pervasives.Lemma (requires None? (FStar.Seq.Properties.find_l f s1))
(ensures
FStar.Seq.Properties.find_l f (FStar.Seq.Base.append s1 s2) ==
FStar.Seq.Properties.find_l f s2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Properties.find_append_none'"
] | [] | true | false | true | false | false | let find_append_none =
| find_append_none' | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_weaken_perm_left | val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k))) | val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k))) | let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 298,
"start_col": 0,
"start_line": 292
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s1: FStar.Seq.Base.seq a ->
s2: FStar.Seq.Base.seq a {FStar.Seq.Base.length s1 = FStar.Seq.Base.length s2} ->
i: Prims.nat ->
j: Prims.nat ->
k: Prims.nat{i <= j /\ j <= k /\ k <= FStar.Seq.Base.length s1}
-> FStar.Pervasives.Lemma
(requires
s1 == FStar.Seq.Properties.splice s2 j s1 k /\
FStar.Seq.Properties.permutation a
(FStar.Seq.Base.slice s2 j k)
(FStar.Seq.Base.slice s1 j k))
(ensures
FStar.Seq.Properties.permutation a
(FStar.Seq.Base.slice s2 i k)
(FStar.Seq.Base.slice s1 i k)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Properties.lemma_append_count",
"FStar.Seq.Base.slice",
"Prims.unit",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.append"
] | [] | true | false | true | false | false | let lemma_weaken_perm_left #_ s1 s2 i j k =
| cut (equal (slice s2 i k) (append (slice s2 i j) (slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j) (slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.find_append_none' | val find_append_none' (#a: Type) (s1 s2: seq a) (f: (a -> Tot bool))
: Lemma (requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1)) | val find_append_none' (#a: Type) (s1 s2: seq a) (f: (a -> Tot bool))
: Lemma (requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1)) | let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 343,
"start_col": 0,
"start_line": 335
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a -> f: (_: a -> Prims.bool)
-> FStar.Pervasives.Lemma (requires None? (FStar.Seq.Properties.find_l f s1))
(ensures
FStar.Seq.Properties.find_l f (FStar.Seq.Base.append s1 s2) ==
FStar.Seq.Properties.find_l f s2)
(decreases FStar.Seq.Base.length s1) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.bool",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.append",
"FStar.Seq.Properties.find_append_none'",
"FStar.Seq.Properties.tail",
"Prims.unit"
] | [
"recursion"
] | false | false | true | false | false | let rec find_append_none': #a: Type -> s1: seq a -> s2: seq a -> f: (a -> Tot bool)
-> Lemma (requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1)) =
| fun #_ s1 s2 f ->
if Seq.length s1 = 0
then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_tail_snoc | val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x)) | val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x)) | let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1 | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 77,
"end_line": 313,
"start_col": 0,
"start_line": 313
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a {FStar.Seq.Base.length s > 0} -> x: a
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Properties.tail (FStar.Seq.Properties.snoc s x) ==
FStar.Seq.Properties.snoc (FStar.Seq.Properties.tail s) x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.lemma_slice_first_in_append",
"FStar.Seq.Base.create",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_tail_snoc #_ s x =
| lemma_slice_first_in_append s (Seq.create 1 x) 1 | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.find_append_some' | val find_append_some' (#a: Type) (s1 s2: seq a) (f: (a -> Tot bool))
: Lemma (requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1)) | val find_append_some' (#a: Type) (s1 s2: seq a) (f: (a -> Tot bool))
: Lemma (requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1)) | let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 331,
"start_col": 0,
"start_line": 323
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a -> f: (_: a -> Prims.bool)
-> FStar.Pervasives.Lemma (requires Some? (FStar.Seq.Properties.find_l f s1))
(ensures
FStar.Seq.Properties.find_l f (FStar.Seq.Base.append s1 s2) ==
FStar.Seq.Properties.find_l f s1)
(decreases FStar.Seq.Base.length s1) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.bool",
"FStar.Seq.Properties.head",
"FStar.Seq.Properties.find_append_some'",
"FStar.Seq.Properties.tail",
"Prims.unit",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.append"
] | [
"recursion"
] | false | false | true | false | false | let rec find_append_some': #a: Type -> s1: seq a -> s2: seq a -> f: (a -> Tot bool)
-> Lemma (requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1)) =
| fun #_ s1 s2 f ->
if f (head s1)
then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_weaken_perm_right | val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k))) | val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k))) | let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 306,
"start_col": 0,
"start_line": 300
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s1: FStar.Seq.Base.seq a ->
s2: FStar.Seq.Base.seq a {FStar.Seq.Base.length s1 = FStar.Seq.Base.length s2} ->
i: Prims.nat ->
j: Prims.nat ->
k: Prims.nat{i <= j /\ j <= k /\ k <= FStar.Seq.Base.length s1}
-> FStar.Pervasives.Lemma
(requires
s1 == FStar.Seq.Properties.splice s2 i s1 j /\
FStar.Seq.Properties.permutation a
(FStar.Seq.Base.slice s2 i j)
(FStar.Seq.Base.slice s1 i j))
(ensures
FStar.Seq.Properties.permutation a
(FStar.Seq.Base.slice s2 i k)
(FStar.Seq.Base.slice s1 i k)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.nat",
"FStar.Seq.Base.length",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Properties.lemma_append_count",
"FStar.Seq.Base.slice",
"Prims.unit",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.append"
] | [] | true | false | true | false | false | let lemma_weaken_perm_right #_ s1 s2 i j k =
| cut (equal (slice s2 i k) (append (slice s2 i j) (slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j) (slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.find_snoc | val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y))) | val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y))) | let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 363,
"start_col": 0,
"start_line": 361
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> x: a -> f: (_: a -> Prims.bool)
-> FStar.Pervasives.Lemma
(ensures
(let res = FStar.Seq.Properties.find_l f (FStar.Seq.Properties.snoc s x) in
(match res with
| FStar.Pervasives.Native.None #_ ->
FStar.Seq.Properties.find_l f s == FStar.Pervasives.Native.None /\
Prims.op_Negation (f x)
| FStar.Pervasives.Native.Some #_ y ->
res == FStar.Seq.Properties.find_l f s \/ f x /\ x == y)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.bool",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Seq.Properties.find_l",
"FStar.Seq.Properties.find_append_some",
"FStar.Seq.Base.create",
"FStar.Seq.Properties.find_append_none",
"Prims.unit"
] | [] | false | false | true | false | false | let find_snoc #_ s x f =
| if Some? (find_l f s)
then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.find_append_none_s2 | val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1)) | val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1)) | let find_append_none_s2 = find_append_none_s2' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 46,
"end_line": 359,
"start_col": 0,
"start_line": 359
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a -> f: (_: a -> Prims.bool)
-> FStar.Pervasives.Lemma (requires None? (FStar.Seq.Properties.find_l f s2))
(ensures
FStar.Seq.Properties.find_l f (FStar.Seq.Base.append s1 s2) ==
FStar.Seq.Properties.find_l f s1) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Properties.find_append_none_s2'"
] | [] | true | false | true | false | false | let find_append_none_s2 =
| find_append_none_s2' | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.un_snoc_snoc | val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x)) | val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x)) | let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s') | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 367,
"start_col": 0,
"start_line": 365
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> x: a
-> FStar.Pervasives.Lemma
(ensures FStar.Seq.Properties.un_snoc (FStar.Seq.Properties.snoc s x) == (s, x)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims._assert",
"FStar.Seq.Base.equal",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc"
] | [] | false | false | true | false | false | let un_snoc_snoc #_ s x =
| let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s') | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.find_l_none_no_index | val find_l_none_no_index (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s)) | val find_l_none_no_index (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s)) | let find_l_none_no_index = find_l_none_no_index' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 492,
"start_col": 0,
"start_line": 492
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> f: (_: a -> Prims.bool)
-> FStar.Pervasives.Lemma (requires None? (FStar.Seq.Properties.find_l f s))
(ensures
forall (i: Prims.nat{i < FStar.Seq.Base.length s}).
Prims.op_Negation (f (FStar.Seq.Base.index s i)))
(decreases FStar.Seq.Base.length s) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Properties.find_l_none_no_index'"
] | [] | true | false | true | false | false | let find_l_none_no_index =
| find_l_none_no_index' | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_mem_snoc | val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y)) | val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y)) | let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 321,
"start_col": 0,
"start_line": 321
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> x: a
-> FStar.Pervasives.Lemma
(ensures
forall (y: a).
FStar.Seq.Properties.mem y (FStar.Seq.Properties.snoc s x) <==>
FStar.Seq.Properties.mem y s \/ x = y) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.lemma_append_count",
"FStar.Seq.Base.create",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_mem_snoc #_ s x =
| lemma_append_count s (Seq.create 1 x) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.find_mem | val find_mem (#a:eqtype) (s:seq a) (f:a -> Tot bool) (x:a{f x})
: Lemma (requires (mem x s))
(ensures (Some? (seq_find f s) /\ f (Some?.v (seq_find f s)))) | val find_mem (#a:eqtype) (s:seq a) (f:a -> Tot bool) (x:a{f x})
: Lemma (requires (mem x s))
(ensures (Some? (seq_find f s) /\ f (Some?.v (seq_find f s)))) | let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> () | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 372,
"start_col": 0,
"start_line": 369
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s') | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> f: (_: a -> Prims.bool) -> x: a{f x}
-> FStar.Pervasives.Lemma (requires FStar.Seq.Properties.mem x s)
(ensures
Some? (FStar.Seq.Properties.seq_find f s) /\ f (Some?.v (FStar.Seq.Properties.seq_find f s))
) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.bool",
"Prims.b2t",
"FStar.Seq.Properties.seq_find",
"FStar.Seq.Properties.mem_index",
"Prims.unit"
] | [] | false | false | true | false | false | let find_mem #_ s f x =
| match seq_find f s with
| None -> mem_index x s
| Some _ -> () | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_seq_list_bij' | val lemma_seq_list_bij' (#a: Type) (s: seq a)
: Lemma (requires (True)) (ensures (seq_of_list (seq_to_list s) == s)) (decreases (length s)) | val lemma_seq_list_bij' (#a: Type) (s: seq a)
: Lemma (requires (True)) (ensures (seq_of_list (seq_to_list s) == s)) (decreases (length s)) | let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 405,
"start_col": 0,
"start_line": 392
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma (ensures FStar.Seq.Base.seq_of_list (FStar.Seq.Base.seq_to_list s) == s)
(decreases FStar.Seq.Base.length s) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.seq_of_list",
"Prims.bool",
"FStar.Seq.Base.seq_to_list",
"Prims.unit",
"FStar.Seq.Properties.lemma_seq_list_bij'",
"FStar.Seq.Base.slice",
"FStar.Seq.Properties.lemma_seq_of_list_induction",
"Prims.list",
"Prims.eq2",
"Prims.nat",
"FStar.List.Tot.Base.length"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_seq_list_bij': #a: Type -> s: seq a
-> Lemma (requires (True)) (ensures (seq_of_list (seq_to_list s) == s)) (decreases (length s)) =
| fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0
then (assert (equal s (seq_of_list l)))
else
(lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.seq_mem_k' | val seq_mem_k' (#a: eqtype) (s: seq a) (n: nat{n < Seq.length s})
: Lemma (requires True) (ensures (mem (Seq.index s n) s)) (decreases n) | val seq_mem_k' (#a: eqtype) (s: seq a) (n: nat{n < Seq.length s})
: Lemma (requires True) (ensures (mem (Seq.index s n) s)) (decreases n) | let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 381,
"start_col": 0,
"start_line": 374
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> n: Prims.nat{n < FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma (ensures FStar.Seq.Properties.mem (FStar.Seq.Base.index s n) s)
(decreases n) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Seq.Properties.seq_mem_k'",
"Prims.op_Subtraction",
"FStar.Seq.Properties.tail",
"Prims.unit"
] | [
"recursion"
] | false | false | true | false | false | let rec seq_mem_k': #a: eqtype -> s: seq a -> n: nat{n < Seq.length s}
-> Lemma (requires True) (ensures (mem (Seq.index s n) s)) (decreases n) =
| fun #_ s n ->
if n = 0
then ()
else
let tl = tail s in
seq_mem_k' tl (n - 1) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_seq_of_list_induction | val lemma_seq_of_list_induction (#a:Type) (l:list a)
:Lemma (requires True)
(ensures (let s = seq_of_list l in
match l with
| [] -> Seq.equal s empty
| hd::tl -> s == cons hd (seq_of_list tl) /\
head s == hd /\ tail s == (seq_of_list tl))) | val lemma_seq_of_list_induction (#a:Type) (l:list a)
:Lemma (requires True)
(ensures (let s = seq_of_list l in
match l with
| [] -> Seq.equal s empty
| hd::tl -> s == cons hd (seq_of_list tl) /\
head s == hd /\ tail s == (seq_of_list tl))) | let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 390,
"start_col": 0,
"start_line": 387
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | l: Prims.list a
-> FStar.Pervasives.Lemma
(ensures
(let s = FStar.Seq.Base.seq_of_list l in
(match l with
| Prims.Nil #_ -> FStar.Seq.Base.equal s FStar.Seq.Base.empty
| Prims.Cons #_ hd tl ->
s == FStar.Seq.Base.cons hd (FStar.Seq.Base.seq_of_list tl) /\
FStar.Seq.Properties.head s == hd /\
FStar.Seq.Properties.tail s == FStar.Seq.Base.seq_of_list tl)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.Seq.Properties.lemma_tl",
"FStar.Seq.Base.seq_of_list",
"Prims.unit"
] | [] | false | false | true | false | false | let lemma_seq_of_list_induction #_ l =
| match l with
| [] -> ()
| hd :: tl -> lemma_tl hd (seq_of_list tl) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_find_l_contains | val lemma_find_l_contains (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l))) | val lemma_find_l_contains (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l))) | let lemma_find_l_contains = lemma_find_l_contains' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 471,
"start_col": 0,
"start_line": 471
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | f: (_: a -> Prims.bool) -> l: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
Some? (FStar.Seq.Properties.find_l f l) ==>
FStar.Seq.Properties.contains l (Some?.v (FStar.Seq.Properties.find_l f l))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Properties.lemma_find_l_contains'"
] | [] | true | false | true | false | false | let lemma_find_l_contains =
| lemma_find_l_contains' | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_index_is_nth | val lemma_index_is_nth: #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i)) | val lemma_index_is_nth: #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i)) | let lemma_index_is_nth = lemma_index_is_nth' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 434,
"start_col": 0,
"start_line": 434
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> i: Prims.nat{i < FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures FStar.List.Tot.Base.index (FStar.Seq.Base.seq_to_list s) i == FStar.Seq.Base.index s i) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Properties.lemma_index_is_nth'"
] | [] | true | false | true | false | false | let lemma_index_is_nth =
| lemma_index_is_nth' | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.find_append_none_s2' | val find_append_none_s2' (#a: Type) (s1 s2: seq a) (f: (a -> Tot bool))
: Lemma (requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1)) | val find_append_none_s2' (#a: Type) (s1 s2: seq a) (f: (a -> Tot bool))
: Lemma (requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1)) | let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 357,
"start_col": 0,
"start_line": 347
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a -> f: (_: a -> Prims.bool)
-> FStar.Pervasives.Lemma (requires None? (FStar.Seq.Properties.find_l f s2))
(ensures
FStar.Seq.Properties.find_l f (FStar.Seq.Base.append s1 s2) ==
FStar.Seq.Properties.find_l f s1)
(decreases FStar.Seq.Base.length s1) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.bool",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.append",
"FStar.Seq.Properties.head",
"FStar.Seq.Properties.tail",
"Prims.unit",
"FStar.Seq.Properties.find_append_none_s2'"
] | [
"recursion"
] | false | false | true | false | false | let rec find_append_none_s2': #a: Type -> s1: seq a -> s2: seq a -> f: (a -> Tot bool)
-> Lemma (requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1)) =
| fun #_ s1 s2 f ->
if Seq.length s1 = 0
then cut (equal (append s1 s2) s2)
else
if f (head s1)
then ()
else
(find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.intro_append_contains_from_disjunction | val intro_append_contains_from_disjunction (#a: Type) (s1 s2: seq a) (x: a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x) (ensures (append s1 s2) `contains` x) | val intro_append_contains_from_disjunction (#a: Type) (s1 s2: seq a) (x: a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x) (ensures (append s1 s2) `contains` x) | let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x))) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 456,
"start_col": 8,
"start_line": 447
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a -> x: a
-> FStar.Pervasives.Lemma
(requires FStar.Seq.Properties.contains s1 x \/ FStar.Seq.Properties.contains s2 x)
(ensures FStar.Seq.Properties.contains (FStar.Seq.Base.append s1 s2) x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Classical.or_elim",
"FStar.Seq.Properties.contains",
"Prims.squash",
"Prims.l_or",
"FStar.Seq.Base.append",
"Prims.unit",
"FStar.Classical.exists_elim",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Squash.get_proof",
"Prims._assert",
"Prims.op_Addition",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let intro_append_contains_from_disjunction (#a: Type) (s1 s2: seq a) (x: a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x) (ensures (append s1 s2) `contains` x) =
| let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x)
#(s2 `contains` x)
#(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ ->
let s = append s1 s2 in
exists_elim (s `contains` x)
(get_proof (s2 `contains` x))
(fun k -> assert (Seq.index s (Seq.length s1 + k) == x))) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_index_is_nth' | val lemma_index_is_nth' (#a: Type) (s: seq a) (i: nat{i < length s})
: Lemma (requires True) (ensures (L.index (seq_to_list s) i == index s i)) (decreases i) | val lemma_index_is_nth' (#a: Type) (s: seq a) (i: nat{i < length s})
: Lemma (requires True) (ensures (L.index (seq_to_list s) i == index s i)) (decreases i) | let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 432,
"start_col": 0,
"start_line": 423
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> i: Prims.nat{i < FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.List.Tot.Base.index (FStar.Seq.Base.seq_to_list s) i == FStar.Seq.Base.index s i)
(decreases i) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Seq.Properties.lemma_index_is_nth'",
"FStar.Seq.Base.slice",
"Prims.op_Subtraction",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.cons",
"FStar.Seq.Properties.head",
"FStar.Seq.Properties.tail"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_index_is_nth': #a: Type -> s: seq a -> i: nat{i < length s}
-> Lemma (requires True) (ensures (L.index (seq_to_list s) i == index s i)) (decreases i) =
| fun #_ s i ->
assert (s `equal` (cons (head s) (tail s)));
if i = 0 then () else (lemma_index_is_nth' (slice s 1 (length s)) (i - 1)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.append_contains_equiv | val append_contains_equiv (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma ((append s1 s2) `contains` x
<==>
(s1 `contains` x \/ s2 `contains` x)) | val append_contains_equiv (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma ((append s1 s2) `contains` x
<==>
(s1 `contains` x \/ s2 `contains` x)) | let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 82,
"end_line": 459,
"start_col": 0,
"start_line": 458
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a -> x: a
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Properties.contains (FStar.Seq.Base.append s1 s2) x <==>
FStar.Seq.Properties.contains s1 x \/ FStar.Seq.Properties.contains s2 x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Classical.move_requires",
"Prims.l_or",
"FStar.Seq.Properties.contains",
"FStar.Seq.Base.append",
"FStar.Seq.Properties.intro_append_contains_from_disjunction",
"Prims.unit"
] | [] | false | false | true | false | false | let append_contains_equiv #_ s1 s2 x =
| FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_find_l_contains' | val lemma_find_l_contains' (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Lemma (requires True)
(ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l)) | val lemma_find_l_contains' (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Lemma (requires True)
(ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l)) | let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 469,
"start_col": 0,
"start_line": 464
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | f: (_: a -> Prims.bool) -> l: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
Some? (FStar.Seq.Properties.find_l f l) ==>
FStar.Seq.Properties.contains l (Some?.v (FStar.Seq.Properties.find_l f l)))
(decreases FStar.Seq.Base.length l) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.bool",
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.head",
"FStar.Seq.Properties.lemma_find_l_contains'",
"FStar.Seq.Properties.tail",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Seq.Properties.find_l",
"FStar.Seq.Properties.contains",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_find_l_contains' (#a: Type) (f: (a -> Tot bool)) (l: seq a)
: Lemma (requires True)
(ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l)) =
| if length l = 0 then () else if f (head l) then () else lemma_find_l_contains' f (tail l) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_list_seq_bij' | val lemma_list_seq_bij' (#a: Type) (l: list a)
: Lemma (requires (True)) (ensures (seq_to_list (seq_of_list l) == l)) (decreases (L.length l)) | val lemma_list_seq_bij' (#a: Type) (l: list a)
: Lemma (requires (True)) (ensures (seq_to_list (seq_of_list l) == l)) (decreases (L.length l)) | let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 419,
"start_col": 0,
"start_line": 409
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | l: Prims.list a
-> FStar.Pervasives.Lemma (ensures FStar.Seq.Base.seq_to_list (FStar.Seq.Base.seq_of_list l) == l)
(decreases FStar.List.Tot.Base.length l) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.list",
"Prims.op_Equality",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.bool",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.seq_of_list",
"FStar.List.Tot.Base.tl",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.length",
"Prims.unit",
"FStar.Seq.Properties.lemma_list_seq_bij'",
"FStar.Seq.Properties.lemma_seq_of_list_induction"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_list_seq_bij': #a: Type -> l: list a
-> Lemma (requires (True)) (ensures (seq_to_list (seq_of_list l) == l)) (decreases (L.length l)) =
| fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0
then ()
else
(lemma_list_seq_bij' (L.tl l);
assert (equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.contains_snoc | val contains_snoc : #a:Type -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. (snoc s x) `contains` y <==> s `contains` y \/ x==y)) | val contains_snoc : #a:Type -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. (snoc s x) `contains` y <==> s `contains` y \/ x==y)) | let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 73,
"end_line": 462,
"start_col": 0,
"start_line": 461
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> x: a
-> FStar.Pervasives.Lemma
(ensures
forall (y: a).
FStar.Seq.Properties.contains (FStar.Seq.Properties.snoc s x) y <==>
FStar.Seq.Properties.contains s y \/ x == y) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Classical.forall_intro",
"Prims.l_iff",
"FStar.Seq.Properties.contains",
"FStar.Seq.Base.append",
"FStar.Seq.Base.create",
"Prims.l_or",
"FStar.Seq.Properties.append_contains_equiv",
"Prims.unit"
] | [] | false | false | true | false | false | let contains_snoc #_ s x =
| FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.contains_cons | val contains_cons (#a:Type) (hd:a) (tl:Seq.seq a) (x:a)
: Lemma ((cons hd tl) `contains` x
<==>
(x==hd \/ tl `contains` x)) | val contains_cons (#a:Type) (hd:a) (tl:Seq.seq a) (x:a)
: Lemma ((cons hd tl) `contains` x
<==>
(x==hd \/ tl `contains` x)) | let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 474,
"start_col": 0,
"start_line": 473
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | hd: a -> tl: FStar.Seq.Base.seq a -> x: a
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Properties.contains (FStar.Seq.Base.cons hd tl) x <==>
x == hd \/ FStar.Seq.Properties.contains tl x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.append_contains_equiv",
"FStar.Seq.Base.create",
"Prims.unit"
] | [] | true | false | true | false | false | let contains_cons #_ hd tl x =
| append_contains_equiv (Seq.create 1 hd) tl x | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.append_cons | val append_cons
(#a: Type)
(c: a)
(s1 s2: seq a)
: Lemma
(ensures (append (cons c s1) s2 == cons c (append s1 s2))) | val append_cons
(#a: Type)
(c: a)
(s1 s2: seq a)
: Lemma
(ensures (append (cons c s1) s2 == cons c (append s1 s2))) | let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 90,
"end_line": 510,
"start_col": 0,
"start_line": 510
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | c: a -> s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.append (FStar.Seq.Base.cons c s1) s2 ==
FStar.Seq.Base.cons c (FStar.Seq.Base.append s1 s2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.append",
"FStar.Seq.Base.cons",
"Prims.unit"
] | [] | true | false | true | false | false | let append_cons #_ c s1 s2 =
| lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_seq_to_list_permutation | val lemma_seq_to_list_permutation (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s)) | val lemma_seq_to_list_permutation (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s)) | let lemma_seq_to_list_permutation = lemma_seq_to_list_permutation' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 66,
"end_line": 602,
"start_col": 0,
"start_line": 602
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q
let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl
let intro_of_list' = intro_of_list''
let intro_of_list #_ s l = intro_of_list' 0 s l
#push-options "--z3rlimit 20"
let rec elim_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
match l with
| [] -> ()
| hd :: tl ->
lemma_seq_of_list_induction l;
elim_of_list'' (i + 1) s tl
#pop-options
let elim_of_list' = elim_of_list''
let elim_of_list #_ l = elim_of_list' 0 (seq_of_list l) l
let rec lemma_seq_to_list_permutation' (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s))
= if length s > 0 then (
assert (equal s (cons (head s) (tail s)));
lemma_seq_to_list_permutation' (slice s 1 (length s))
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
forall (x: a).
FStar.Seq.Properties.count x s ==
FStar.List.Tot.Base.count x (FStar.Seq.Base.seq_to_list s))
(decreases FStar.Seq.Base.length s) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Properties.lemma_seq_to_list_permutation'"
] | [] | true | false | true | false | false | let lemma_seq_to_list_permutation =
| lemma_seq_to_list_permutation' | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.find_l_none_no_index' | val find_l_none_no_index' (#a: Type) (s: Seq.seq a) (f: (a -> Tot bool))
: Lemma (requires (None? (find_l f s)))
(ensures (forall (i: nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s)) | val find_l_none_no_index' (#a: Type) (s: Seq.seq a) (f: (a -> Tot bool))
: Lemma (requires (None? (find_l f s)))
(ensures (forall (i: nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s)) | let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 490,
"start_col": 0,
"start_line": 480
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> f: (_: a -> Prims.bool)
-> FStar.Pervasives.Lemma (requires None? (FStar.Seq.Properties.find_l f s))
(ensures
forall (i: Prims.nat{i < FStar.Seq.Base.length s}).
Prims.op_Negation (f (FStar.Seq.Base.index s i)))
(decreases FStar.Seq.Base.length s) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.bool",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.find_append_none",
"FStar.Seq.Base.create",
"FStar.Seq.Properties.head",
"FStar.Seq.Properties.tail",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.cons",
"FStar.Seq.Properties.find_l_none_no_index'",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_None",
"FStar.Seq.Properties.find_l",
"Prims.op_Negation",
"Prims.squash",
"Prims.l_Forall",
"Prims.nat",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec find_l_none_no_index' (#a: Type) (s: Seq.seq a) (f: (a -> Tot bool))
: Lemma (requires (None? (find_l f s)))
(ensures (forall (i: nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s)) =
| if Seq.length s = 0
then ()
else
(assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.cons_head_tail | val cons_head_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures (s == cons (head s) (tail s)))
[SMTPat (cons (head s) (tail s))] | val cons_head_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures (s == cons (head s) (tail s)))
[SMTPat (cons (head s) (tail s))] | let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1 | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 500,
"start_col": 0,
"start_line": 494
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a {FStar.Seq.Base.length s > 0}
-> FStar.Pervasives.Lemma
(ensures s == FStar.Seq.Base.cons (FStar.Seq.Properties.head s) (FStar.Seq.Properties.tail s))
[SMTPat (FStar.Seq.Base.cons (FStar.Seq.Properties.head s) (FStar.Seq.Properties.tail s))] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.lemma_split",
"Prims.squash",
"Prims.eq2",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.create",
"FStar.Seq.Base.index",
"FStar.Seq.Base.lemma_eq_elim",
"Prims.unit",
"FStar.Seq.Base.lemma_index_create",
"FStar.Seq.Base.lemma_index_slice"
] | [] | true | false | true | false | false | let cons_head_tail #_ s =
| let _:squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1 | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.slice_is_empty | val slice_is_empty
(#a: Type)
(s: seq a)
(i: nat {i <= length s})
: Lemma
(requires True)
(ensures (slice s i i == Seq.empty))
[SMTPat (slice s i i)] | val slice_is_empty
(#a: Type)
(s: seq a)
(i: nat {i <= length s})
: Lemma
(requires True)
(ensures (slice s i i == Seq.empty))
[SMTPat (slice s i i)] | let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 520,
"start_col": 0,
"start_line": 520
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> i: Prims.nat{i <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma (ensures FStar.Seq.Base.slice s i i == FStar.Seq.Base.empty)
[SMTPat (FStar.Seq.Base.slice s i i)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.empty",
"Prims.unit"
] | [] | true | false | true | false | false | let slice_is_empty #_ s i =
| lemma_eq_elim (slice s i i) Seq.empty | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.mem_cons | val mem_cons
(#a:eqtype)
(x:a)
(s:seq a)
: Lemma
(ensures (forall y. mem y (cons x s) <==> mem y s \/ x=y)) | val mem_cons
(#a:eqtype)
(x:a)
(s:seq a)
: Lemma
(ensures (forall y. mem y (cons x s) <==> mem y s \/ x=y)) | let mem_cons #_ x s = lemma_append_count (create 1 x) s | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 55,
"end_line": 514,
"start_col": 0,
"start_line": 514
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | x: a -> s: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
forall (y: a).
FStar.Seq.Properties.mem y (FStar.Seq.Base.cons x s) <==>
FStar.Seq.Properties.mem y s \/ x = y) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.lemma_append_count",
"FStar.Seq.Base.create",
"Prims.unit"
] | [] | true | false | true | false | false | let mem_cons #_ x s =
| lemma_append_count (create 1 x) s | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.cons_index_slice | val cons_index_slice
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i < j /\ j <= length s} )
(k:nat{k == i+1})
: Lemma
(requires True)
(ensures (cons (index s i) (slice s k j) == slice s i j))
[SMTPat (cons (index s i) (slice s k j))] | val cons_index_slice
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i < j /\ j <= length s} )
(k:nat{k == i+1})
: Lemma
(requires True)
(ensures (cons (index s i) (slice s k j) == slice s i j))
[SMTPat (cons (index s i) (slice s k j))] | let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 100,
"end_line": 518,
"start_col": 0,
"start_line": 518
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s: FStar.Seq.Base.seq a ->
i: Prims.nat ->
j: Prims.nat{i < j /\ j <= FStar.Seq.Base.length s} ->
k: Prims.nat{k == i + 1}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.cons (FStar.Seq.Base.index s i) (FStar.Seq.Base.slice s k j) ==
FStar.Seq.Base.slice s i j)
[SMTPat (FStar.Seq.Base.cons (FStar.Seq.Base.index s i) (FStar.Seq.Base.slice s k j))] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.cons",
"FStar.Seq.Base.index",
"FStar.Seq.Base.slice",
"Prims.unit"
] | [] | true | false | true | false | false | let cons_index_slice #_ s i j _ =
| lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.suffix_of_tail | val suffix_of_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures ((tail s) `suffix_of` s))
[SMTPat ((tail s) `suffix_of` s)] | val suffix_of_tail
(#a: Type)
(s: seq a {length s > 0})
: Lemma
(requires True)
(ensures ((tail s) `suffix_of` s))
[SMTPat ((tail s) `suffix_of` s)] | let suffix_of_tail #_ s = cons_head_tail s | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 504,
"start_col": 0,
"start_line": 504
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a {FStar.Seq.Base.length s > 0}
-> FStar.Pervasives.Lemma (ensures FStar.Seq.Properties.suffix_of (FStar.Seq.Properties.tail s) s)
[SMTPat (FStar.Seq.Properties.suffix_of (FStar.Seq.Properties.tail s) s)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.cons_head_tail",
"Prims.unit"
] | [] | true | false | true | false | false | let suffix_of_tail #_ s =
| cons_head_tail s | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.seq_of_list_tl | val seq_of_list_tl
(#a: Type)
(l: list a { List.Tot.length l > 0 } )
: Lemma
(requires True)
(ensures (seq_of_list (List.Tot.tl l) == tail (seq_of_list l))) | val seq_of_list_tl
(#a: Type)
(l: list a { List.Tot.length l > 0 } )
: Lemma
(requires True)
(ensures (seq_of_list (List.Tot.tl l) == tail (seq_of_list l))) | let seq_of_list_tl #_ l = lemma_seq_of_list_induction l | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 55,
"end_line": 532,
"start_col": 0,
"start_line": 532
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | l: Prims.list a {FStar.List.Tot.Base.length l > 0}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.seq_of_list (FStar.List.Tot.Base.tl l) ==
FStar.Seq.Properties.tail (FStar.Seq.Base.seq_of_list l)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.List.Tot.Base.length",
"FStar.Seq.Properties.lemma_seq_of_list_induction",
"Prims.unit"
] | [] | true | false | true | false | false | let seq_of_list_tl #_ l =
| lemma_seq_of_list_induction l | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.mem_seq_of_list | val mem_seq_of_list
(#a: eqtype)
(x: a)
(l: list a)
: Lemma
(requires True)
(ensures (mem x (seq_of_list l) == List.Tot.mem x l))
[SMTPat (mem x (seq_of_list l))] | val mem_seq_of_list
(#a: eqtype)
(x: a)
(l: list a)
: Lemma
(requires True)
(ensures (mem x (seq_of_list l) == List.Tot.mem x l))
[SMTPat (mem x (seq_of_list l))] | let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 544,
"start_col": 0,
"start_line": 534
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | x: a -> l: Prims.list a
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Properties.mem x (FStar.Seq.Base.seq_of_list l) == FStar.List.Tot.Base.mem x l)
[SMTPat (FStar.Seq.Properties.mem x (FStar.Seq.Base.seq_of_list l))] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"Prims.list",
"FStar.Seq.Properties.mem_seq_of_list",
"Prims.squash",
"Prims.eq2",
"Prims.bool",
"FStar.Seq.Properties.mem",
"FStar.Seq.Base.seq_of_list",
"Prims.op_BarBar",
"Prims.op_Equality",
"FStar.Seq.Properties.lemma_mem_inversion",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.tail",
"FStar.Seq.Properties.seq_of_list_tl",
"FStar.Seq.Properties.head",
"Prims.unit",
"FStar.Seq.Properties.lemma_seq_of_list_induction"
] | [
"recursion"
] | false | false | true | false | false | let rec mem_seq_of_list #_ x l =
| lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _:squash (head (seq_of_list l) == y) = () in
let _:squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _:squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q | false |
Hacl.HPKE.Interface.Hash.fst | Hacl.HPKE.Interface.Hash.hash_sha512 | val hash_sha512:Hash.hash_st Spec.Agile.Hash.SHA2_512 | val hash_sha512:Hash.hash_st Spec.Agile.Hash.SHA2_512 | let hash_sha512 : Hash.hash_st Spec.Agile.Hash.SHA2_512 =
Hacl.Streaming.SHA2.hash_512 | {
"file_name": "code/hpke/Hacl.HPKE.Interface.Hash.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 17,
"start_col": 0,
"start_line": 16
} | module Hacl.HPKE.Interface.Hash
module S = Spec.Agile.HPKE
module Hash = Hacl.Hash.Definitions
[@ Meta.Attribute.specialize ]
noextract
assume val hash: #cs:S.ciphersuite -> Hash.hash_st (S.hash_of_cs cs)
(** Instantiations of hash **)
inline_for_extraction noextract
let hash_sha256 : Hash.hash_st Spec.Agile.Hash.SHA2_256 =
Hacl.Streaming.SHA2.hash_256 | {
"checked_file": "/",
"dependencies": [
"Spec.Agile.HPKE.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Hacl.Streaming.SHA2.fst.checked",
"Hacl.Hash.Definitions.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.HPKE.Interface.Hash.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Hash.Definitions",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.HPKE",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.HPKE.Interface",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE.Interface",
"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 | Hacl.Hash.Definitions.hash_st Spec.Hash.Definitions.SHA2_512 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Streaming.SHA2.hash_512"
] | [] | false | false | false | true | false | let hash_sha512:Hash.hash_st Spec.Agile.Hash.SHA2_512 =
| Hacl.Streaming.SHA2.hash_512 | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.slice_length | val slice_length
(#a: Type)
(s: seq a)
: Lemma
(requires True)
(ensures (slice s 0 (length s) == s))
[SMTPat (slice s 0 (length s))] | val slice_length
(#a: Type)
(s: seq a)
: Lemma
(requires True)
(ensures (slice s 0 (length s) == s))
[SMTPat (slice s 0 (length s))] | let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 522,
"start_col": 0,
"start_line": 522
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma (ensures FStar.Seq.Base.slice s 0 (FStar.Seq.Base.length s) == s)
[SMTPat (FStar.Seq.Base.slice s 0 (FStar.Seq.Base.length s))] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.length",
"Prims.unit"
] | [] | true | false | true | false | false | let slice_length #_ s =
| lemma_eq_elim (slice s 0 (length s)) s | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.snoc_slice_index | val snoc_slice_index
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i <= j /\ j < length s} )
: Lemma
(requires True)
(ensures (snoc (slice s i j) (index s j) == slice s i (j + 1)))
[SMTPat (snoc (slice s i j) (index s j))] | val snoc_slice_index
(#a: Type)
(s: seq a)
(i: nat)
(j: nat {i <= j /\ j < length s} )
: Lemma
(requires True)
(ensures (snoc (slice s i j) (index s j) == slice s i (j + 1)))
[SMTPat (snoc (slice s i j) (index s j))] | let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 98,
"end_line": 516,
"start_col": 0,
"start_line": 516
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> i: Prims.nat -> j: Prims.nat{i <= j /\ j < FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Properties.snoc (FStar.Seq.Base.slice s i j) (FStar.Seq.Base.index s j) ==
FStar.Seq.Base.slice s i (j + 1))
[SMTPat (FStar.Seq.Properties.snoc (FStar.Seq.Base.slice s i j) (FStar.Seq.Base.index s j))] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Properties.snoc",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.index",
"Prims.op_Addition",
"Prims.unit"
] | [] | true | false | true | false | false | let snoc_slice_index #_ s i j =
| lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.intro_of_list' | val intro_of_list': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s)))) | val intro_of_list': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s)))) | let intro_of_list' = intro_of_list'' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 565,
"start_col": 0,
"start_line": 565
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q
let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | i: Prims.nat -> s: FStar.Seq.Base.seq a -> l: Prims.list a
-> FStar.Pervasives.Lemma
(requires
FStar.List.Tot.Base.length l + i = FStar.Seq.Base.length s /\ i <= FStar.Seq.Base.length s /\
FStar.Seq.Properties.explode_and i s l)
(ensures
FStar.Seq.Base.equal (FStar.Seq.Base.seq_of_list l)
(FStar.Seq.Base.slice s i (FStar.Seq.Base.length s))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Properties.intro_of_list''"
] | [] | true | false | true | false | false | let intro_of_list' =
| intro_of_list'' | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.elim_of_list' | val elim_of_list': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l)) | val elim_of_list': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l)) | let elim_of_list' = elim_of_list'' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 591,
"start_col": 0,
"start_line": 591
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q
let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl
let intro_of_list' = intro_of_list''
let intro_of_list #_ s l = intro_of_list' 0 s l
#push-options "--z3rlimit 20"
let rec elim_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
match l with
| [] -> ()
| hd :: tl ->
lemma_seq_of_list_induction l;
elim_of_list'' (i + 1) s tl
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | i: Prims.nat -> s: FStar.Seq.Base.seq a -> l: Prims.list a
-> FStar.Pervasives.Lemma
(requires
FStar.List.Tot.Base.length l + i = FStar.Seq.Base.length s /\ i <= FStar.Seq.Base.length s /\
FStar.Seq.Base.slice s i (FStar.Seq.Base.length s) == FStar.Seq.Base.seq_of_list l)
(ensures FStar.Seq.Properties.explode_and i s l) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Properties.elim_of_list''"
] | [] | true | false | true | false | false | let elim_of_list' =
| elim_of_list'' | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_seq_of_list_index | val lemma_seq_of_list_index (#a:Type) (l:list a) (i:nat{i < List.Tot.length l})
:Lemma (requires True)
(ensures (index (seq_of_list l) i == List.Tot.index l i))
[SMTPat (index (seq_of_list l) i)] | val lemma_seq_of_list_index (#a:Type) (l:list a) (i:nat{i < List.Tot.length l})
:Lemma (requires True)
(ensures (index (seq_of_list l) i == List.Tot.index l i))
[SMTPat (index (seq_of_list l) i)] | let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 72,
"end_line": 530,
"start_col": 0,
"start_line": 526
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | l: Prims.list a -> i: Prims.nat{i < FStar.List.Tot.Base.length l}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.index (FStar.Seq.Base.seq_of_list l) i == FStar.List.Tot.Base.index l i)
[SMTPat (FStar.Seq.Base.index (FStar.Seq.Base.seq_of_list l) i)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Seq.Properties.lemma_seq_of_list_index",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.Seq.Properties.lemma_seq_of_list_induction"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_seq_of_list_index #_ l i =
| lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.map_seq_append | val map_seq_append (#a #b:Type) (f:a -> Tot b) (s1 s2:Seq.seq a)
: Lemma (ensures (map_seq f (Seq.append s1 s2) ==
Seq.append (map_seq f s1) (map_seq f s2))) | val map_seq_append (#a #b:Type) (f:a -> Tot b) (s1 s2:Seq.seq a)
: Lemma (ensures (map_seq f (Seq.append s1 s2) ==
Seq.append (map_seq f s1) (map_seq f s2))) | let map_seq_append #a #b f s1 s2 =
map_seq_len f s1;
map_seq_len f s2;
map_seq_len f (Seq.append s1 s2);
Classical.forall_intro (map_seq_index f s1);
Classical.forall_intro (map_seq_index f s2);
Classical.forall_intro (map_seq_index f (Seq.append s1 s2));
assert (Seq.equal (map_seq f (Seq.append s1 s2))
(Seq.append (map_seq f s1) (map_seq f s2))) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 63,
"end_line": 667,
"start_col": 0,
"start_line": 659
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q
let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl
let intro_of_list' = intro_of_list''
let intro_of_list #_ s l = intro_of_list' 0 s l
#push-options "--z3rlimit 20"
let rec elim_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
match l with
| [] -> ()
| hd :: tl ->
lemma_seq_of_list_induction l;
elim_of_list'' (i + 1) s tl
#pop-options
let elim_of_list' = elim_of_list''
let elim_of_list #_ l = elim_of_list' 0 (seq_of_list l) l
let rec lemma_seq_to_list_permutation' (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s))
= if length s > 0 then (
assert (equal s (cons (head s) (tail s)));
lemma_seq_to_list_permutation' (slice s 1 (length s))
)
let lemma_seq_to_list_permutation = lemma_seq_to_list_permutation'
let rec lemma_seq_of_list_permutation #a l
=
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| _::tl -> lemma_seq_of_list_permutation tl
let rec lemma_seq_of_list_sorted #a f l
=
lemma_seq_of_list_induction l;
if List.Tot.length l > 1 then begin
lemma_seq_of_list_induction (List.Tot.Base.tl l);
lemma_seq_of_list_sorted f (List.Tot.Base.tl l)
end
let lemma_seq_sortwith_correctness #_ f s
= let l = seq_to_list s in
let l' = List.Tot.Base.sortWith f l in
let s' = seq_of_list l' in
let cmp = List.Tot.Base.bool_of_compare f in
(* sortedness *)
List.Tot.Properties.sortWith_sorted f l; //the list returned by List.sortWith is sorted
lemma_seq_of_list_sorted cmp l'; //seq_of_list preserves sortedness
(* permutation *)
lemma_seq_to_list_permutation s; //seq_to_list is a permutation
List.Tot.Properties.sortWith_permutation f l; //List.sortWith is a permutation
lemma_seq_of_list_permutation l' //seq_of_list is a permutation
(****** Seq map ******)
let rec map_seq #a #b f s : Tot (Seq.seq b) (decreases Seq.length s) =
if Seq.length s = 0
then Seq.empty
else let hd, tl = head s, tail s in
cons (f hd) (map_seq f tl)
let rec map_seq_len #a #b f s
: Lemma (ensures Seq.length (map_seq f s) == Seq.length s) (decreases Seq.length s)
= if Seq.length s = 0
then ()
else map_seq_len f (tail s)
let rec map_seq_index #a #b f s i
: Lemma (ensures (map_seq_len f s; Seq.index (map_seq f s) i == f (Seq.index s i))) (decreases Seq.length s)
= map_seq_len f s;
if Seq.length s = 0
then ()
else if i = 0
then ()
else map_seq_index f (tail s) (i-1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | f: (_: a -> b) -> s1: FStar.Seq.Base.seq a -> s2: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Properties.map_seq f (FStar.Seq.Base.append s1 s2) ==
FStar.Seq.Base.append (FStar.Seq.Properties.map_seq f s1) (FStar.Seq.Properties.map_seq f s2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Properties.map_seq",
"FStar.Seq.Base.append",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Seq.Properties.map_seq_index",
"FStar.Seq.Properties.map_seq_len"
] | [] | false | false | true | false | false | let map_seq_append #a #b f s1 s2 =
| map_seq_len f s1;
map_seq_len f s2;
map_seq_len f (Seq.append s1 s2);
Classical.forall_intro (map_seq_index f s1);
Classical.forall_intro (map_seq_index f s2);
Classical.forall_intro (map_seq_index f (Seq.append s1 s2));
assert (Seq.equal (map_seq f (Seq.append s1 s2)) (Seq.append (map_seq f s1) (map_seq f s2))) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_seq_of_list_permutation | val lemma_seq_of_list_permutation (#a:eqtype) (l:list a)
:Lemma (forall x. List.Tot.Base.count x l == count x (seq_of_list l)) | val lemma_seq_of_list_permutation (#a:eqtype) (l:list a)
:Lemma (forall x. List.Tot.Base.count x l == count x (seq_of_list l)) | let rec lemma_seq_of_list_permutation #a l
=
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| _::tl -> lemma_seq_of_list_permutation tl | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 609,
"start_col": 0,
"start_line": 604
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q
let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl
let intro_of_list' = intro_of_list''
let intro_of_list #_ s l = intro_of_list' 0 s l
#push-options "--z3rlimit 20"
let rec elim_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
match l with
| [] -> ()
| hd :: tl ->
lemma_seq_of_list_induction l;
elim_of_list'' (i + 1) s tl
#pop-options
let elim_of_list' = elim_of_list''
let elim_of_list #_ l = elim_of_list' 0 (seq_of_list l) l
let rec lemma_seq_to_list_permutation' (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s))
= if length s > 0 then (
assert (equal s (cons (head s) (tail s)));
lemma_seq_to_list_permutation' (slice s 1 (length s))
)
let lemma_seq_to_list_permutation = lemma_seq_to_list_permutation' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | l: Prims.list a
-> FStar.Pervasives.Lemma
(ensures
forall (x: a).
FStar.List.Tot.Base.count x l == FStar.Seq.Properties.count x (FStar.Seq.Base.seq_of_list l)
) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"Prims.list",
"FStar.Seq.Properties.lemma_seq_of_list_permutation",
"Prims.unit",
"FStar.Seq.Properties.lemma_seq_of_list_induction"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_seq_of_list_permutation #a l =
| lemma_seq_of_list_induction l;
match l with
| [] -> ()
| _ :: tl -> lemma_seq_of_list_permutation tl | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.intro_of_list | val intro_of_list (#a: Type) (s: seq a) (l: list a):
Lemma
(requires (
List.Tot.length l = length s /\
pointwise_and s l))
(ensures (
s == seq_of_list l)) | val intro_of_list (#a: Type) (s: seq a) (l: list a):
Lemma
(requires (
List.Tot.length l = length s /\
pointwise_and s l))
(ensures (
s == seq_of_list l)) | let intro_of_list #_ s l = intro_of_list' 0 s l | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 567,
"start_col": 0,
"start_line": 567
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q
let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl
let intro_of_list' = intro_of_list'' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a -> l: Prims.list a
-> FStar.Pervasives.Lemma
(requires
FStar.List.Tot.Base.length l = FStar.Seq.Base.length s /\
FStar.Seq.Properties.pointwise_and s l) (ensures s == FStar.Seq.Base.seq_of_list l) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.list",
"FStar.Seq.Properties.intro_of_list'",
"Prims.unit"
] | [] | true | false | true | false | false | let intro_of_list #_ s l =
| intro_of_list' 0 s l | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.slice_slice | val slice_slice
(#a: Type)
(s: seq a)
(i1: nat)
(j1: nat {i1 <= j1 /\ j1 <= length s} )
(i2: nat)
(j2: nat {i2 <= j2 /\ j2 <= j1 - i1} )
: Lemma
(requires True)
(ensures (slice (slice s i1 j1) i2 j2 == slice s (i1 + i2) (i1 + j2)))
[SMTPat (slice (slice s i1 j1) i2 j2)] | val slice_slice
(#a: Type)
(s: seq a)
(i1: nat)
(j1: nat {i1 <= j1 /\ j1 <= length s} )
(i2: nat)
(j2: nat {i2 <= j2 /\ j2 <= j1 - i1} )
: Lemma
(requires True)
(ensures (slice (slice s i1 j1) i2 j2 == slice s (i1 + i2) (i1 + j2)))
[SMTPat (slice (slice s i1 j1) i2 j2)] | let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2)) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 108,
"end_line": 524,
"start_col": 0,
"start_line": 524
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 |
s: FStar.Seq.Base.seq a ->
i1: Prims.nat ->
j1: Prims.nat{i1 <= j1 /\ j1 <= FStar.Seq.Base.length s} ->
i2: Prims.nat ->
j2: Prims.nat{i2 <= j2 /\ j2 <= j1 - i1}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (FStar.Seq.Base.slice s i1 j1) i2 j2 ==
FStar.Seq.Base.slice s (i1 + i2) (i1 + j2))
[SMTPat (FStar.Seq.Base.slice (FStar.Seq.Base.slice s i1 j1) i2 j2)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.op_Subtraction",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.unit"
] | [] | true | false | true | false | false | let slice_slice #_ s i1 j1 i2 j2 =
| lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_seq_of_list_sorted | val lemma_seq_of_list_sorted (#a:Type) (f:a -> a -> Tot bool) (l:list a)
:Lemma (requires (List.Tot.Properties.sorted f l)) (ensures (sorted f (seq_of_list l))) | val lemma_seq_of_list_sorted (#a:Type) (f:a -> a -> Tot bool) (l:list a)
:Lemma (requires (List.Tot.Properties.sorted f l)) (ensures (sorted f (seq_of_list l))) | let rec lemma_seq_of_list_sorted #a f l
=
lemma_seq_of_list_induction l;
if List.Tot.length l > 1 then begin
lemma_seq_of_list_induction (List.Tot.Base.tl l);
lemma_seq_of_list_sorted f (List.Tot.Base.tl l)
end | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 7,
"end_line": 617,
"start_col": 0,
"start_line": 611
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q
let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl
let intro_of_list' = intro_of_list''
let intro_of_list #_ s l = intro_of_list' 0 s l
#push-options "--z3rlimit 20"
let rec elim_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
match l with
| [] -> ()
| hd :: tl ->
lemma_seq_of_list_induction l;
elim_of_list'' (i + 1) s tl
#pop-options
let elim_of_list' = elim_of_list''
let elim_of_list #_ l = elim_of_list' 0 (seq_of_list l) l
let rec lemma_seq_to_list_permutation' (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s))
= if length s > 0 then (
assert (equal s (cons (head s) (tail s)));
lemma_seq_to_list_permutation' (slice s 1 (length s))
)
let lemma_seq_to_list_permutation = lemma_seq_to_list_permutation'
let rec lemma_seq_of_list_permutation #a l
=
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| _::tl -> lemma_seq_of_list_permutation tl | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | f: (_: a -> _: a -> Prims.bool) -> l: Prims.list a
-> FStar.Pervasives.Lemma (requires FStar.List.Tot.Properties.sorted f l)
(ensures FStar.Seq.Properties.sorted f (FStar.Seq.Base.seq_of_list l)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.bool",
"Prims.list",
"Prims.op_GreaterThan",
"FStar.List.Tot.Base.length",
"FStar.Seq.Properties.lemma_seq_of_list_sorted",
"FStar.List.Tot.Base.tl",
"Prims.unit",
"FStar.Seq.Properties.lemma_seq_of_list_induction"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_seq_of_list_sorted #a f l =
| lemma_seq_of_list_induction l;
if List.Tot.length l > 1
then
(lemma_seq_of_list_induction (List.Tot.Base.tl l);
lemma_seq_of_list_sorted f (List.Tot.Base.tl l)) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.map_seq_len | val map_seq_len (#a #b:Type) (f:a -> Tot b) (s:Seq.seq a)
: Lemma (ensures Seq.length (map_seq f s) == Seq.length s) | val map_seq_len (#a #b:Type) (f:a -> Tot b) (s:Seq.seq a)
: Lemma (ensures Seq.length (map_seq f s) == Seq.length s) | let rec map_seq_len #a #b f s
: Lemma (ensures Seq.length (map_seq f s) == Seq.length s) (decreases Seq.length s)
= if Seq.length s = 0
then ()
else map_seq_len f (tail s) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 648,
"start_col": 0,
"start_line": 644
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q
let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl
let intro_of_list' = intro_of_list''
let intro_of_list #_ s l = intro_of_list' 0 s l
#push-options "--z3rlimit 20"
let rec elim_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
match l with
| [] -> ()
| hd :: tl ->
lemma_seq_of_list_induction l;
elim_of_list'' (i + 1) s tl
#pop-options
let elim_of_list' = elim_of_list''
let elim_of_list #_ l = elim_of_list' 0 (seq_of_list l) l
let rec lemma_seq_to_list_permutation' (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s))
= if length s > 0 then (
assert (equal s (cons (head s) (tail s)));
lemma_seq_to_list_permutation' (slice s 1 (length s))
)
let lemma_seq_to_list_permutation = lemma_seq_to_list_permutation'
let rec lemma_seq_of_list_permutation #a l
=
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| _::tl -> lemma_seq_of_list_permutation tl
let rec lemma_seq_of_list_sorted #a f l
=
lemma_seq_of_list_induction l;
if List.Tot.length l > 1 then begin
lemma_seq_of_list_induction (List.Tot.Base.tl l);
lemma_seq_of_list_sorted f (List.Tot.Base.tl l)
end
let lemma_seq_sortwith_correctness #_ f s
= let l = seq_to_list s in
let l' = List.Tot.Base.sortWith f l in
let s' = seq_of_list l' in
let cmp = List.Tot.Base.bool_of_compare f in
(* sortedness *)
List.Tot.Properties.sortWith_sorted f l; //the list returned by List.sortWith is sorted
lemma_seq_of_list_sorted cmp l'; //seq_of_list preserves sortedness
(* permutation *)
lemma_seq_to_list_permutation s; //seq_to_list is a permutation
List.Tot.Properties.sortWith_permutation f l; //List.sortWith is a permutation
lemma_seq_of_list_permutation l' //seq_of_list is a permutation
(****** Seq map ******)
let rec map_seq #a #b f s : Tot (Seq.seq b) (decreases Seq.length s) =
if Seq.length s = 0
then Seq.empty
else let hd, tl = head s, tail s in
cons (f hd) (map_seq f tl) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | f: (_: a -> b) -> s: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures FStar.Seq.Base.length (FStar.Seq.Properties.map_seq f s) == FStar.Seq.Base.length s)
(decreases FStar.Seq.Base.length s) | FStar.Pervasives.Lemma | [
"",
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.bool",
"FStar.Seq.Properties.map_seq_len",
"FStar.Seq.Properties.tail",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Properties.map_seq",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec map_seq_len #a #b f s
: Lemma (ensures Seq.length (map_seq f s) == Seq.length s) (decreases Seq.length s) =
| if Seq.length s = 0 then () else map_seq_len f (tail s) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_seq_sortwith_correctness | val lemma_seq_sortwith_correctness (#a:eqtype) (f:a -> a -> Tot int) (s:seq a)
:Lemma (requires (total_order a (List.Tot.Base.bool_of_compare f)))
(ensures (let s' = sortWith f s in sorted (List.Tot.Base.bool_of_compare f) s' /\ permutation a s s')) | val lemma_seq_sortwith_correctness (#a:eqtype) (f:a -> a -> Tot int) (s:seq a)
:Lemma (requires (total_order a (List.Tot.Base.bool_of_compare f)))
(ensures (let s' = sortWith f s in sorted (List.Tot.Base.bool_of_compare f) s' /\ permutation a s s')) | let lemma_seq_sortwith_correctness #_ f s
= let l = seq_to_list s in
let l' = List.Tot.Base.sortWith f l in
let s' = seq_of_list l' in
let cmp = List.Tot.Base.bool_of_compare f in
(* sortedness *)
List.Tot.Properties.sortWith_sorted f l; //the list returned by List.sortWith is sorted
lemma_seq_of_list_sorted cmp l'; //seq_of_list preserves sortedness
(* permutation *)
lemma_seq_to_list_permutation s; //seq_to_list is a permutation
List.Tot.Properties.sortWith_permutation f l; //List.sortWith is a permutation
lemma_seq_of_list_permutation l' | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 633,
"start_col": 0,
"start_line": 620
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q
let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl
let intro_of_list' = intro_of_list''
let intro_of_list #_ s l = intro_of_list' 0 s l
#push-options "--z3rlimit 20"
let rec elim_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
match l with
| [] -> ()
| hd :: tl ->
lemma_seq_of_list_induction l;
elim_of_list'' (i + 1) s tl
#pop-options
let elim_of_list' = elim_of_list''
let elim_of_list #_ l = elim_of_list' 0 (seq_of_list l) l
let rec lemma_seq_to_list_permutation' (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s))
= if length s > 0 then (
assert (equal s (cons (head s) (tail s)));
lemma_seq_to_list_permutation' (slice s 1 (length s))
)
let lemma_seq_to_list_permutation = lemma_seq_to_list_permutation'
let rec lemma_seq_of_list_permutation #a l
=
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| _::tl -> lemma_seq_of_list_permutation tl
let rec lemma_seq_of_list_sorted #a f l
=
lemma_seq_of_list_induction l;
if List.Tot.length l > 1 then begin
lemma_seq_of_list_induction (List.Tot.Base.tl l);
lemma_seq_of_list_sorted f (List.Tot.Base.tl l)
end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | f: (_: a -> _: a -> Prims.int) -> s: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(requires FStar.Seq.Properties.total_order a (FStar.List.Tot.Base.bool_of_compare f))
(ensures
(let s' = FStar.Seq.Properties.sortWith f s in
FStar.Seq.Properties.sorted (FStar.List.Tot.Base.bool_of_compare f) s' /\
FStar.Seq.Properties.permutation a s s')) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"Prims.int",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.lemma_seq_of_list_permutation",
"Prims.unit",
"FStar.List.Tot.Properties.sortWith_permutation",
"FStar.Seq.Properties.lemma_seq_to_list_permutation",
"FStar.Seq.Properties.lemma_seq_of_list_sorted",
"FStar.List.Tot.Properties.sortWith_sorted",
"Prims.bool",
"FStar.List.Tot.Base.bool_of_compare",
"Prims.eq2",
"Prims.nat",
"FStar.List.Tot.Base.length",
"FStar.Seq.Base.length",
"FStar.Seq.Base.seq_of_list",
"Prims.list",
"FStar.List.Tot.Base.sortWith",
"FStar.Seq.Base.seq_to_list"
] | [] | true | false | true | false | false | let lemma_seq_sortwith_correctness #_ f s =
| let l = seq_to_list s in
let l' = List.Tot.Base.sortWith f l in
let s' = seq_of_list l' in
let cmp = List.Tot.Base.bool_of_compare f in
List.Tot.Properties.sortWith_sorted f l;
lemma_seq_of_list_sorted cmp l';
lemma_seq_to_list_permutation s;
List.Tot.Properties.sortWith_permutation f l;
lemma_seq_of_list_permutation l' | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.map_seq | val map_seq (#a #b:Type) (f:a -> Tot b) (s:Seq.seq a) : Tot (Seq.seq b) | val map_seq (#a #b:Type) (f:a -> Tot b) (s:Seq.seq a) : Tot (Seq.seq b) | let rec map_seq #a #b f s : Tot (Seq.seq b) (decreases Seq.length s) =
if Seq.length s = 0
then Seq.empty
else let hd, tl = head s, tail s in
cons (f hd) (map_seq f tl) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 642,
"start_col": 0,
"start_line": 638
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q
let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl
let intro_of_list' = intro_of_list''
let intro_of_list #_ s l = intro_of_list' 0 s l
#push-options "--z3rlimit 20"
let rec elim_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
match l with
| [] -> ()
| hd :: tl ->
lemma_seq_of_list_induction l;
elim_of_list'' (i + 1) s tl
#pop-options
let elim_of_list' = elim_of_list''
let elim_of_list #_ l = elim_of_list' 0 (seq_of_list l) l
let rec lemma_seq_to_list_permutation' (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s))
= if length s > 0 then (
assert (equal s (cons (head s) (tail s)));
lemma_seq_to_list_permutation' (slice s 1 (length s))
)
let lemma_seq_to_list_permutation = lemma_seq_to_list_permutation'
let rec lemma_seq_of_list_permutation #a l
=
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| _::tl -> lemma_seq_of_list_permutation tl
let rec lemma_seq_of_list_sorted #a f l
=
lemma_seq_of_list_induction l;
if List.Tot.length l > 1 then begin
lemma_seq_of_list_induction (List.Tot.Base.tl l);
lemma_seq_of_list_sorted f (List.Tot.Base.tl l)
end
let lemma_seq_sortwith_correctness #_ f s
= let l = seq_to_list s in
let l' = List.Tot.Base.sortWith f l in
let s' = seq_of_list l' in
let cmp = List.Tot.Base.bool_of_compare f in
(* sortedness *)
List.Tot.Properties.sortWith_sorted f l; //the list returned by List.sortWith is sorted
lemma_seq_of_list_sorted cmp l'; //seq_of_list preserves sortedness
(* permutation *)
lemma_seq_to_list_permutation s; //seq_to_list is a permutation
List.Tot.Properties.sortWith_permutation f l; //List.sortWith is a permutation
lemma_seq_of_list_permutation l' //seq_of_list is a permutation
(****** Seq map ******) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | f: (_: a -> b) -> s: FStar.Seq.Base.seq a -> Prims.Tot (FStar.Seq.Base.seq b) | Prims.Tot | [
"",
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Prims.bool",
"Prims.precedes",
"Prims.nat",
"FStar.Seq.Base.cons",
"FStar.Seq.Properties.map_seq",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Properties.head",
"FStar.Seq.Properties.tail"
] | [
"recursion"
] | false | false | false | true | false | let rec map_seq #a #b f s : Tot (Seq.seq b) (decreases Seq.length s) =
| if Seq.length s = 0
then Seq.empty
else
let hd, tl = head s, tail s in
cons (f hd) (map_seq f tl) | false |
Hacl.HPKE.Interface.Hash.fst | Hacl.HPKE.Interface.Hash.hash_sha256 | val hash_sha256:Hash.hash_st Spec.Agile.Hash.SHA2_256 | val hash_sha256:Hash.hash_st Spec.Agile.Hash.SHA2_256 | let hash_sha256 : Hash.hash_st Spec.Agile.Hash.SHA2_256 =
Hacl.Streaming.SHA2.hash_256 | {
"file_name": "code/hpke/Hacl.HPKE.Interface.Hash.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 14,
"start_col": 0,
"start_line": 13
} | module Hacl.HPKE.Interface.Hash
module S = Spec.Agile.HPKE
module Hash = Hacl.Hash.Definitions
[@ Meta.Attribute.specialize ]
noextract
assume val hash: #cs:S.ciphersuite -> Hash.hash_st (S.hash_of_cs cs)
(** Instantiations of hash **) | {
"checked_file": "/",
"dependencies": [
"Spec.Agile.HPKE.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Hacl.Streaming.SHA2.fst.checked",
"Hacl.Hash.Definitions.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.HPKE.Interface.Hash.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Hash.Definitions",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.HPKE",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.HPKE.Interface",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE.Interface",
"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 | Hacl.Hash.Definitions.hash_st Spec.Hash.Definitions.SHA2_256 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Streaming.SHA2.hash_256"
] | [] | false | false | false | true | false | let hash_sha256:Hash.hash_st Spec.Agile.Hash.SHA2_256 =
| Hacl.Streaming.SHA2.hash_256 | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_swap_permutes_aux | val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j))) | val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j))) | let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 189,
"start_col": 0,
"start_line": 164
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
s: FStar.Seq.Base.seq a ->
i: Prims.nat{i < FStar.Seq.Base.length s} ->
j: Prims.nat{i <= j && j < FStar.Seq.Base.length s} ->
x: a
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Properties.count x s =
FStar.Seq.Properties.count x (FStar.Seq.Properties.swap s i j)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.l_or",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Seq.Properties.swap",
"Prims.bool",
"FStar.Seq.Properties.lemma_append_count_aux",
"Prims.unit",
"FStar.Seq.Base.append",
"FStar.Seq.Properties.lemma_swap_permutes_aux_frag_eq",
"Prims.op_Addition",
"FStar.Pervasives.Native.tuple5",
"FStar.Pervasives.Native.Mktuple5",
"FStar.Seq.Base.index",
"FStar.Seq.Properties.split_5"
] | [] | false | false | true | false | false | let lemma_swap_permutes_aux #_ s i j x =
| if j = i
then cut (equal (swap s i j) s)
else
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4
in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4
in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.map_seq_index | val map_seq_index (#a #b:Type) (f:a -> Tot b) (s:Seq.seq a) (i:nat{i < Seq.length s})
: Lemma (ensures (map_seq_len f s; Seq.index (map_seq f s) i == f (Seq.index s i))) | val map_seq_index (#a #b:Type) (f:a -> Tot b) (s:Seq.seq a) (i:nat{i < Seq.length s})
: Lemma (ensures (map_seq_len f s; Seq.index (map_seq f s) i == f (Seq.index s i))) | let rec map_seq_index #a #b f s i
: Lemma (ensures (map_seq_len f s; Seq.index (map_seq f s) i == f (Seq.index s i))) (decreases Seq.length s)
= map_seq_len f s;
if Seq.length s = 0
then ()
else if i = 0
then ()
else map_seq_index f (tail s) (i-1) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 657,
"start_col": 0,
"start_line": 650
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q
let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl
let intro_of_list' = intro_of_list''
let intro_of_list #_ s l = intro_of_list' 0 s l
#push-options "--z3rlimit 20"
let rec elim_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
match l with
| [] -> ()
| hd :: tl ->
lemma_seq_of_list_induction l;
elim_of_list'' (i + 1) s tl
#pop-options
let elim_of_list' = elim_of_list''
let elim_of_list #_ l = elim_of_list' 0 (seq_of_list l) l
let rec lemma_seq_to_list_permutation' (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s))
= if length s > 0 then (
assert (equal s (cons (head s) (tail s)));
lemma_seq_to_list_permutation' (slice s 1 (length s))
)
let lemma_seq_to_list_permutation = lemma_seq_to_list_permutation'
let rec lemma_seq_of_list_permutation #a l
=
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| _::tl -> lemma_seq_of_list_permutation tl
let rec lemma_seq_of_list_sorted #a f l
=
lemma_seq_of_list_induction l;
if List.Tot.length l > 1 then begin
lemma_seq_of_list_induction (List.Tot.Base.tl l);
lemma_seq_of_list_sorted f (List.Tot.Base.tl l)
end
let lemma_seq_sortwith_correctness #_ f s
= let l = seq_to_list s in
let l' = List.Tot.Base.sortWith f l in
let s' = seq_of_list l' in
let cmp = List.Tot.Base.bool_of_compare f in
(* sortedness *)
List.Tot.Properties.sortWith_sorted f l; //the list returned by List.sortWith is sorted
lemma_seq_of_list_sorted cmp l'; //seq_of_list preserves sortedness
(* permutation *)
lemma_seq_to_list_permutation s; //seq_to_list is a permutation
List.Tot.Properties.sortWith_permutation f l; //List.sortWith is a permutation
lemma_seq_of_list_permutation l' //seq_of_list is a permutation
(****** Seq map ******)
let rec map_seq #a #b f s : Tot (Seq.seq b) (decreases Seq.length s) =
if Seq.length s = 0
then Seq.empty
else let hd, tl = head s, tail s in
cons (f hd) (map_seq f tl)
let rec map_seq_len #a #b f s
: Lemma (ensures Seq.length (map_seq f s) == Seq.length s) (decreases Seq.length s)
= if Seq.length s = 0
then ()
else map_seq_len f (tail s) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | f: (_: a -> b) -> s: FStar.Seq.Base.seq a -> i: Prims.nat{i < FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
(FStar.Seq.Properties.map_seq_len f s;
FStar.Seq.Base.index (FStar.Seq.Properties.map_seq f s) i == f (FStar.Seq.Base.index s i))
) (decreases FStar.Seq.Base.length s) | FStar.Pervasives.Lemma | [
"",
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Seq.Properties.map_seq_index",
"FStar.Seq.Properties.tail",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.Seq.Properties.map_seq_len",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Seq.Properties.map_seq",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec map_seq_index #a #b f s i
: Lemma
(ensures
(map_seq_len f s;
Seq.index (map_seq f s) i == f (Seq.index s i))) (decreases Seq.length s) =
| map_seq_len f s;
if Seq.length s = 0 then () else if i = 0 then () else map_seq_index f (tail s) (i - 1) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.lemma_seq_to_list_permutation' | val lemma_seq_to_list_permutation' (#a: eqtype) (s: seq a)
: Lemma (requires True)
(ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s)))
(decreases (length s)) | val lemma_seq_to_list_permutation' (#a: eqtype) (s: seq a)
: Lemma (requires True)
(ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s)))
(decreases (length s)) | let rec lemma_seq_to_list_permutation' (#a:eqtype) (s:seq a)
:Lemma (requires True) (ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s))) (decreases (length s))
= if length s > 0 then (
assert (equal s (cons (head s) (tail s)));
lemma_seq_to_list_permutation' (slice s 1 (length s))
) | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 600,
"start_col": 0,
"start_line": 595
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q
let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl
let intro_of_list' = intro_of_list''
let intro_of_list #_ s l = intro_of_list' 0 s l
#push-options "--z3rlimit 20"
let rec elim_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
match l with
| [] -> ()
| hd :: tl ->
lemma_seq_of_list_induction l;
elim_of_list'' (i + 1) s tl
#pop-options
let elim_of_list' = elim_of_list''
let elim_of_list #_ l = elim_of_list' 0 (seq_of_list l) l | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | s: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
forall (x: a).
FStar.Seq.Properties.count x s ==
FStar.List.Tot.Base.count x (FStar.Seq.Base.seq_to_list s))
(decreases FStar.Seq.Base.length s) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.eqtype",
"FStar.Seq.Base.seq",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.lemma_seq_to_list_permutation'",
"FStar.Seq.Base.slice",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.cons",
"FStar.Seq.Properties.head",
"FStar.Seq.Properties.tail",
"Prims.bool",
"Prims.l_True",
"Prims.squash",
"Prims.l_Forall",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Properties.count",
"FStar.List.Tot.Base.count",
"FStar.Seq.Base.seq_to_list",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_seq_to_list_permutation' (#a: eqtype) (s: seq a)
: Lemma (requires True)
(ensures (forall x. count x s == List.Tot.Base.count x (seq_to_list s)))
(decreases (length s)) =
| if length s > 0
then
(assert (equal s (cons (head s) (tail s)));
lemma_seq_to_list_permutation' (slice s 1 (length s))) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.intro_of_list'' | val intro_of_list'' (#a: Type) (i: nat) (s: seq a) (l: list a)
: Lemma (requires (List.Tot.length l + i = length s /\ i <= length s /\ explode_and i s l))
(ensures (equal (seq_of_list l) (slice s i (length s))))
(decreases (List.Tot.length l)) | val intro_of_list'' (#a: Type) (i: nat) (s: seq a) (l: list a)
: Lemma (requires (List.Tot.length l + i = length s /\ i <= length s /\ explode_and i s l))
(ensures (equal (seq_of_list l) (slice s i (length s))))
(decreases (List.Tot.length l)) | let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 563,
"start_col": 0,
"start_line": 546
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | i: Prims.nat -> s: FStar.Seq.Base.seq a -> l: Prims.list a
-> FStar.Pervasives.Lemma
(requires
FStar.List.Tot.Base.length l + i = FStar.Seq.Base.length s /\ i <= FStar.Seq.Base.length s /\
FStar.Seq.Properties.explode_and i s l)
(ensures
FStar.Seq.Base.equal (FStar.Seq.Base.seq_of_list l)
(FStar.Seq.Base.slice s i (FStar.Seq.Base.length s)))
(decreases FStar.List.Tot.Base.length l) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"Prims.nat",
"FStar.Seq.Base.seq",
"Prims.list",
"FStar.Seq.Properties.intro_of_list''",
"Prims.op_Addition",
"Prims.unit",
"FStar.Seq.Properties.lemma_seq_of_list_induction"
] | [
"recursion"
] | false | false | true | false | false | let rec intro_of_list'': #a: Type -> i: nat -> s: seq a -> l: list a
-> Lemma (requires (List.Tot.length l + i = length s /\ i <= length s /\ explode_and i s l))
(ensures (equal (seq_of_list l) (slice s i (length s))))
(decreases (List.Tot.length l)) =
| fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl | false |
LowStar.Vector.fst | LowStar.Vector.vector | val vector (a: Type0): Tot Type0 | val vector (a: Type0): Tot Type0 | let vector a = vector_str a | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 62,
"start_col": 0,
"start_line": 62
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 | a: Type0 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"LowStar.Vector.vector_str"
] | [] | false | false | false | true | true | let vector a =
| vector_str a | false |
LowStar.Vector.fst | LowStar.Vector.max_uint32 | val max_uint32: uint32_t | val max_uint32: uint32_t | let max_uint32 = 4294967295ul | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 49,
"start_col": 0,
"start_line": 49
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 | LowStar.Vector.uint32_t | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.__uint_to_t"
] | [] | false | false | false | true | false | let max_uint32 =
| 4294967295ul | false |
LowStar.Vector.fst | LowStar.Vector.freeable | val freeable: #a:Type -> vector a -> GTot Type0 | val freeable: #a:Type -> vector a -> GTot Type0 | let freeable #a vec =
B.freeable (Vec?.vs vec) | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 98,
"start_col": 0,
"start_line": 97
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a
val vector (a: Type0): Tot Type0
let vector a = vector_str a
/// Specification
val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)})
let as_seq h #a vec =
B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec))
/// Capacity
inline_for_extraction val size_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let size_of #a vec =
Vec?.sz vec
inline_for_extraction val capacity_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let capacity_of #a vec =
Vec?.cap vec
val is_empty: #a:Type -> vec:vector a -> Tot bool
let is_empty #a vec =
size_of vec = 0ul
val is_full: #a:Type -> vstr:vector_str a -> GTot bool
let is_full #a vstr =
Vec?.sz vstr >= max_uint32
/// Memory-related
val live: #a:Type -> HS.mem -> vector a -> GTot Type0
let live #a h vec =
B.live h (Vec?.vs vec) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 | vec: LowStar.Vector.vector a -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Vector.vector",
"LowStar.Monotonic.Buffer.freeable",
"LowStar.Buffer.trivial_preorder",
"LowStar.Vector.__proj__Vec__item__vs"
] | [] | false | false | false | false | true | let freeable #a vec =
| B.freeable (Vec?.vs vec) | false |
LowStar.Vector.fst | LowStar.Vector.is_full | val is_full: #a:Type -> vstr:vector_str a -> GTot bool | val is_full: #a:Type -> vstr:vector_str a -> GTot bool | let is_full #a vstr =
Vec?.sz vstr >= max_uint32 | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 88,
"start_col": 0,
"start_line": 87
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a
val vector (a: Type0): Tot Type0
let vector a = vector_str a
/// Specification
val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)})
let as_seq h #a vec =
B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec))
/// Capacity
inline_for_extraction val size_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let size_of #a vec =
Vec?.sz vec
inline_for_extraction val capacity_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let capacity_of #a vec =
Vec?.cap vec
val is_empty: #a:Type -> vec:vector a -> Tot bool
let is_empty #a vec =
size_of vec = 0ul | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 | vstr: LowStar.Vector.vector_str a -> Prims.GTot Prims.bool | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Vector.vector_str",
"FStar.Integers.op_Greater_Equals",
"FStar.Integers.Unsigned",
"FStar.Integers.W32",
"LowStar.Vector.__proj__Vec__item__sz",
"LowStar.Vector.max_uint32",
"Prims.bool"
] | [] | false | false | false | false | false | let is_full #a vstr =
| Vec?.sz vstr >= max_uint32 | false |
LowStar.Vector.fst | LowStar.Vector.is_empty | val is_empty: #a:Type -> vec:vector a -> Tot bool | val is_empty: #a:Type -> vec:vector a -> Tot bool | let is_empty #a vec =
size_of vec = 0ul | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 84,
"start_col": 0,
"start_line": 83
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a
val vector (a: Type0): Tot Type0
let vector a = vector_str a
/// Specification
val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)})
let as_seq h #a vec =
B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec))
/// Capacity
inline_for_extraction val size_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let size_of #a vec =
Vec?.sz vec
inline_for_extraction val capacity_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let capacity_of #a vec =
Vec?.cap vec | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 | vec: LowStar.Vector.vector a -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"LowStar.Vector.vector",
"Prims.op_Equality",
"FStar.UInt32.t",
"LowStar.Vector.size_of",
"FStar.UInt32.__uint_to_t",
"Prims.bool"
] | [] | false | false | false | true | false | let is_empty #a vec =
| size_of vec = 0ul | false |
LowStar.Vector.fst | LowStar.Vector.size_of | val size_of: #a:Type -> vec:vector a -> Tot uint32_t | val size_of: #a:Type -> vec:vector a -> Tot uint32_t | let size_of #a vec =
Vec?.sz vec | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 76,
"start_col": 22,
"start_line": 75
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a
val vector (a: Type0): Tot Type0
let vector a = vector_str a
/// Specification
val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)})
let as_seq h #a vec =
B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec))
/// Capacity | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 | vec: LowStar.Vector.vector a -> LowStar.Vector.uint32_t | Prims.Tot | [
"total"
] | [] | [
"LowStar.Vector.vector",
"LowStar.Vector.__proj__Vec__item__sz",
"LowStar.Vector.uint32_t"
] | [] | false | false | false | true | false | let size_of #a vec =
| Vec?.sz vec | false |
Vale.Transformers.Locations.fst | Vale.Transformers.Locations.downgrade_val_raise_val_u0_u1 | val downgrade_val_raise_val_u0_u1 :
#a:Type0 ->
x:a ->
Lemma
(ensures FStar.Universe.downgrade_val u#0 u#1 (FStar.Universe.raise_val x) == x)
[SMTPat (FStar.Universe.raise_val x)] | val downgrade_val_raise_val_u0_u1 :
#a:Type0 ->
x:a ->
Lemma
(ensures FStar.Universe.downgrade_val u#0 u#1 (FStar.Universe.raise_val x) == x)
[SMTPat (FStar.Universe.raise_val x)] | let downgrade_val_raise_val_u0_u1 #a x = FStar.Universe.downgrade_val_raise_val #a x | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.Locations.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 84,
"end_line": 47,
"start_col": 0,
"start_line": 47
} | module Vale.Transformers.Locations
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Bytes_Code_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Machine_s
open Vale.X64.Print_s
open Vale.Def.PossiblyMonad
module L = FStar.List.Tot
(* See fsti *)
type location : eqtype =
| ALocMem : location
| ALocStack: location
| ALocReg : reg -> location
| ALocCf : location
| ALocOf : location
let aux_print_reg_from_location (a:location{ALocReg? a}) : string =
let ALocReg (Reg file id) = a in
match file with
| 0 -> print_reg_name id
| 1 -> print_xmm id gcc
(* See fsti *)
let disjoint_location a1 a2 =
match a1, a2 with
| ALocCf, ALocCf -> ffalse "carry flag not disjoint from itself"
| ALocOf, ALocOf -> ffalse "overflow flag not disjoint from itself"
| ALocCf, _ | ALocOf, _ | _, ALocCf | _, ALocOf -> ttrue
| ALocMem, ALocMem -> ffalse "memory not disjoint from itself"
| ALocStack, ALocStack -> ffalse "stack not disjoint from itself"
| ALocMem, ALocStack | ALocStack, ALocMem -> ttrue
| ALocReg r1, ALocReg r2 ->
(r1 <> r2) /- ("register " ^ aux_print_reg_from_location a1 ^ " not disjoint from itself")
| ALocReg _, _ | _, ALocReg _ -> ttrue
(* See fsti *)
let auto_lemma_disjoint_location a1 a2 = () | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Def.PossiblyMonad.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Transformers.Locations.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Def.PossiblyMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Def.PossiblyMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"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": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | x: a
-> FStar.Pervasives.Lemma (ensures FStar.Universe.downgrade_val (FStar.Universe.raise_val x) == x)
[SMTPat (FStar.Universe.raise_val x)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Universe.downgrade_val_raise_val",
"Prims.unit"
] | [] | true | false | true | false | false | let downgrade_val_raise_val_u0_u1 #a x =
| FStar.Universe.downgrade_val_raise_val #a x | false |
LowStar.Vector.fst | LowStar.Vector.live | val live: #a:Type -> HS.mem -> vector a -> GTot Type0 | val live: #a:Type -> HS.mem -> vector a -> GTot Type0 | let live #a h vec =
B.live h (Vec?.vs vec) | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 24,
"end_line": 94,
"start_col": 0,
"start_line": 93
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a
val vector (a: Type0): Tot Type0
let vector a = vector_str a
/// Specification
val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)})
let as_seq h #a vec =
B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec))
/// Capacity
inline_for_extraction val size_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let size_of #a vec =
Vec?.sz vec
inline_for_extraction val capacity_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let capacity_of #a vec =
Vec?.cap vec
val is_empty: #a:Type -> vec:vector a -> Tot bool
let is_empty #a vec =
size_of vec = 0ul
val is_full: #a:Type -> vstr:vector_str a -> GTot bool
let is_full #a vstr =
Vec?.sz vstr >= max_uint32
/// Memory-related | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 | h: FStar.Monotonic.HyperStack.mem -> vec: LowStar.Vector.vector a -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"LowStar.Vector.vector",
"LowStar.Monotonic.Buffer.live",
"LowStar.Buffer.trivial_preorder",
"LowStar.Vector.__proj__Vec__item__vs"
] | [] | false | false | false | false | true | let live #a h vec =
| B.live h (Vec?.vs vec) | false |
FStar.Seq.Properties.fst | FStar.Seq.Properties.elim_of_list | val elim_of_list (#a: Type) (l: list a):
Lemma
(ensures (
let s = seq_of_list l in
pointwise_and s l)) | val elim_of_list (#a: Type) (l: list a):
Lemma
(ensures (
let s = seq_of_list l in
pointwise_and s l)) | let elim_of_list #_ l = elim_of_list' 0 (seq_of_list l) l | {
"file_name": "ulib/FStar.Seq.Properties.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 593,
"start_col": 0,
"start_line": 593
} | (*
Copyright 2008-2014 Nikhil Swamy and 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.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lemma_append_inj_l #_ s1 s2 t1 t2 i =
assert (index s1 i == (index (append s1 s2) i));
assert (index t1 i == (index (append t1 t2) i))
let lemma_append_inj_r #_ s1 s2 t1 t2 i =
assert (index s2 i == (index (append s1 s2) (i + length s1)));
assert (index t2 i == (index (append t1 t2) (i + length t1)))
let lemma_append_len_disj #_ s1 s2 t1 t2 =
cut (length (append s1 s2) == length s1 + length s2);
cut (length (append t1 t2) == length t1 + length t2)
let lemma_append_inj #_ s1 s2 t1 t2 =
lemma_append_len_disj s1 s2 t1 t2;
FStar.Classical.forall_intro #(i:nat{i < length s1}) #(fun i -> index s1 i == index t1 i) (lemma_append_inj_l s1 s2 t1 t2);
FStar.Classical.forall_intro #(i:nat{i < length s2}) #(fun i -> index s2 i == index t2 i) (lemma_append_inj_r s1 s2 t1 t2)
let lemma_head_append #_ _ _ = ()
let lemma_tail_append #_ s1 s2 = cut (equal (tail (append s1 s2)) (append (tail s1) s2))
let lemma_cons_inj #_ v1 v2 s1 s2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj t1 s1 t2 s2;
assert(index t1 0 == index t2 0)
let lemma_split #_ s i =
cut (equal (append (fst (split s i)) (snd (split s i))) s)
let rec mem_index' (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(decreases (length s))
= if length s = 0 then ()
else if head s = x then ()
else mem_index' x (tail s)
let mem_index = mem_index'
let lemma_slice_append #_ _ _ = ()
let rec lemma_slice_first_in_append' (#a:Type) (s1:seq a) (s2:seq a)
(i:nat{i <= length s1})
: Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
(decreases (length s1))
= if i = 0 then ()
else lemma_slice_first_in_append' (tail s1) s2 (i - 1)
let lemma_slice_first_in_append = lemma_slice_first_in_append'
let slice_upd #_ s i j k v =
lemma_eq_intro (slice (upd s k v) i j) (slice s i j)
let upd_slice #_ s i j k v =
lemma_eq_intro (upd (slice s i j) k v) (slice (upd s (i + k) v) i j)
let lemma_append_cons #_ _ _ = ()
let lemma_tl #_ _ _ = ()
let rec sorted_feq' (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
(decreases (length s))
= if length s <= 1 then ()
else sorted_feq' f g (tail s)
let sorted_feq = sorted_feq'
let rec lemma_append_count' (#a:eqtype) (lo:seq a) (hi:seq a)
: Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
(decreases (length lo))
= if length lo = 0
then cut (equal (append lo hi) hi)
else (cut (equal (cons (head lo) (append (tail lo) hi))
(append lo hi));
lemma_append_count' (tail lo) hi;
let tl_l_h = append (tail lo) hi in
let lh = cons (head lo) tl_l_h in
cut (equal (tail lh) tl_l_h))
let lemma_append_count = lemma_append_count'
let lemma_append_count_aux #_ _ lo hi = lemma_append_count lo hi
let lemma_mem_inversion #_ _ = ()
let rec lemma_mem_count' (#a:eqtype) (s:seq a) (f:a -> Tot bool)
: Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
(decreases (length s))
= if length s = 0
then ()
else (let t = i:nat{i<length (tail s)} in
cut (forall (i:t). index (tail s) i = index s (i + 1));
lemma_mem_count' (tail s) f)
let lemma_mem_count = lemma_mem_count'
let lemma_count_slice #_ s i =
cut (equal s (append (slice s 0 i) (slice s i (length s))));
lemma_append_count (slice s 0 i) (slice s i (length s))
let rec sorted_concat_lemma': #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
(decreases (length lo))
= fun #_ f lo pivot hi ->
if length lo = 0
then (cut (equal (append lo (cons pivot hi)) (cons pivot hi));
cut (equal (tail (cons pivot hi)) hi))
else (sorted_concat_lemma' f (tail lo) pivot hi;
lemma_append_cons lo (cons pivot hi);
lemma_tl (head lo) (append (tail lo) (cons pivot hi)))
let sorted_concat_lemma = sorted_concat_lemma'
let split_5 #a s i j =
let frag_lo = slice s 0 i in
let frag_i = slice s i (i + 1) in
let frag_mid = slice s (i + 1) j in
let frag_j = slice s j (j + 1) in
let frag_hi = slice s (j + 1) (length s) in
upd (upd (upd (upd (create 5 frag_lo) 1 frag_i) 2 frag_mid) 3 frag_j) 4 frag_hi
let lemma_swap_permutes_aux_frag_eq #a s i j i' j' =
cut (equal (slice s i' j') (slice (swap s i j) i' j'));
cut (equal (slice s i (i + 1)) (slice (swap s i j) j (j + 1)));
cut (equal (slice s j (j + 1)) (slice (swap s i j) i (i + 1)))
#push-options "--z3rlimit 20"
let lemma_swap_permutes_aux #_ s i j x =
if j=i
then cut (equal (swap s i j) s)
else begin
let s5 = split_5 s i j in
let frag_lo, frag_i, frag_mid, frag_j, frag_hi =
index s5 0, index s5 1, index s5 2, index s5 3, index s5 4 in
lemma_append_count_aux x frag_lo (append frag_i (append frag_mid (append frag_j frag_hi)));
lemma_append_count_aux x frag_i (append frag_mid (append frag_j frag_hi));
lemma_append_count_aux x frag_mid (append frag_j frag_hi);
lemma_append_count_aux x frag_j frag_hi;
let s' = swap s i j in
let s5' = split_5 s' i j in
let frag_lo', frag_j', frag_mid', frag_i', frag_hi' =
index s5' 0, index s5' 1, index s5' 2, index s5' 3, index s5' 4 in
lemma_swap_permutes_aux_frag_eq s i j 0 i;
lemma_swap_permutes_aux_frag_eq s i j (i + 1) j;
lemma_swap_permutes_aux_frag_eq s i j (j + 1) (length s);
lemma_append_count_aux x frag_lo (append frag_j (append frag_mid (append frag_i frag_hi)));
lemma_append_count_aux x frag_j (append frag_mid (append frag_i frag_hi));
lemma_append_count_aux x frag_mid (append frag_i frag_hi);
lemma_append_count_aux x frag_i frag_hi
end
#pop-options
let append_permutations #a s1 s2 s1' s2' =
(
lemma_append_count s1 s2;
lemma_append_count s1' s2'
)
let lemma_swap_permutes #a s i j
= FStar.Classical.forall_intro
#a
#(fun x -> count x s = count x (swap s i j))
(lemma_swap_permutes_aux s i j)
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
//a proof optimization: Z3 only needs to unfold the recursive definition of `count` once
#push-options "--fuel 1 --ifuel 1 --z3rlimit 20"
let rec perm_len' (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
(decreases (length s1))
= if length s1 = 0 then begin
if length s2 = 0 then ()
else assert (count (index s2 0) s2 > 0)
end
else let s1_hd = head s1 in
let s1_tl = tail s1 in
assert (count s1_hd s1 > 0);
assert (count s1_hd s2 > 0);
assert (length s2 > 0);
let s2_hd = head s2 in
let s2_tl = tail s2 in
if s1_hd = s2_hd
then (assert (permutation a s1_tl s2_tl); perm_len' s1_tl s2_tl)
else let i = index_mem s1_hd s2 in
let s_pfx, s_sfx = split_eq s2 i in
assert (equal s_sfx (append (create 1 s1_hd) (tail s_sfx)));
let s2' = append s_pfx (tail s_sfx) in
lemma_append_count s_pfx s_sfx;
lemma_append_count (create 1 s1_hd) (tail s_sfx);
lemma_append_count s_pfx (tail s_sfx);
assert (permutation a s1_tl s2');
perm_len' s1_tl s2'
#pop-options
let perm_len = perm_len'
let cons_perm #_ tl s = lemma_tl (head s) tl
let lemma_mem_append #_ s1 s2 = lemma_append_count s1 s2
let lemma_slice_cons #_ s i j =
cut (equal (slice s i j) (append (create 1 (index s i)) (slice s (i + 1) j)));
lemma_mem_append (create 1 (index s i)) (slice s (i + 1) j)
let lemma_slice_snoc #_ s i j =
cut (equal (slice s i j) (append (slice s i (j - 1)) (create 1 (index s (j - 1)))));
lemma_mem_append (slice s i (j - 1)) (create 1 (index s (j - 1)))
let lemma_ordering_lo_snoc #_ f s i j pv =
cut (equal (slice s i (j + 1)) (append (slice s i j) (create 1 (index s j))));
lemma_mem_append (slice s i j) (create 1 (index s j))
let lemma_ordering_hi_cons #_ f s back len pv =
cut (equal (slice s back len) (append (create 1 (index s back)) (slice s (back + 1) len)));
lemma_mem_append (create 1 (index s back)) (slice s (back + 1) len)
let swap_frame_lo #_ s lo i j = cut (equal (slice s lo i) (slice (swap s i j) lo i))
let swap_frame_lo' #_ s lo i' i j = cut (equal (slice s lo i') (slice (swap s i j) lo i'))
let swap_frame_hi #_ s i j k hi = cut (equal (slice s k hi) (slice (swap s i j) k hi))
let lemma_swap_slice_commute #_ s start i j len =
cut (equal (slice (swap s i j) start len) (swap (slice s start len) (i - start) (j - start)))
let lemma_swap_permutes_slice #_ s start i j len =
lemma_swap_slice_commute s start i j len;
lemma_swap_permutes (slice s start len) (i - start) (j - start)
let splice_refl #_ s i j = cut (equal s (splice s i s j))
let lemma_swap_splice #_ s start i j len = cut (equal (swap s i j) (splice s start (swap s i j) len))
let lemma_seq_frame_hi #_ s1 s2 i j m n =
cut (equal (slice s1 m n) (slice s2 m n))
let lemma_seq_frame_lo #_ s1 s2 i j m n =
cut (equal (slice s1 i j) (slice s2 i j))
let lemma_tail_slice #_ s i j =
cut (equal (tail (slice s i j)) (slice s (i + 1) j))
let lemma_weaken_frame_right #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_weaken_frame_left #_ s1 s2 i j k = cut (equal s1 (splice s2 i s1 k))
let lemma_trans_frame #_ s1 s2 s3 i j = cut (equal s1 (splice s3 i s1 j))
let lemma_weaken_perm_left #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s2 i j)
(slice s1 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s2 i j) (slice s1 j k)
let lemma_weaken_perm_right #_ s1 s2 i j k =
cut (equal (slice s2 i k) (append (slice s2 i j)
(slice s2 j k)));
cut (equal (slice s1 i k) (append (slice s1 i j)
(slice s2 j k)));
lemma_append_count (slice s2 i j) (slice s2 j k);
lemma_append_count (slice s1 i j) (slice s2 j k)
let lemma_trans_perm #_ _ _ _ _ _ = ()
let lemma_cons_snoc #_ _ _ _ = ()
let lemma_tail_snoc #_ s x = lemma_slice_first_in_append s (Seq.create 1 x) 1
let lemma_snoc_inj #_ s1 s2 v1 v2 =
let t1 = create 1 v1 in
let t2 = create 1 v2 in
lemma_append_inj s1 t1 s2 t2;
assert(head t1 == head t2)
let lemma_mem_snoc #_ s x = lemma_append_count s (Seq.create 1 x)
let rec find_append_some': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if f (head s1) then ()
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_some' (tail s1) s2 f
let find_append_some = find_append_some'
let rec find_append_none': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else
let _ = cut (equal (tail (append s1 s2)) (append (tail s1) s2)) in
find_append_none' (tail s1) s2 f
let find_append_none = find_append_none'
let rec find_append_none_s2': #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
(decreases (length s1))
= fun #_ s1 s2 f ->
if Seq.length s1 = 0 then cut (equal (append s1 s2) s2)
else if f (head s1) then ()
else begin
find_append_none_s2' (tail s1) s2 f;
cut (equal (tail (append s1 s2)) (append (tail s1) s2))
end
let find_append_none_s2 = find_append_none_s2'
let find_snoc #_ s x f =
if Some? (find_l f s) then find_append_some s (Seq.create 1 x) f
else find_append_none s (Seq.create 1 x) f
let un_snoc_snoc #_ s x =
let s', x = un_snoc (snoc s x) in
assert (Seq.equal s s')
let find_mem #_ s f x
= match seq_find f s with
| None -> mem_index x s
| Some _ -> ()
let rec seq_mem_k': #a:eqtype -> s:seq a -> n:nat{n < Seq.length s} ->
Lemma (requires True)
(ensures (mem (Seq.index s n) s))
(decreases n)
= fun #_ s n ->
if n = 0 then ()
else let tl = tail s in
seq_mem_k' tl (n - 1)
let seq_mem_k = seq_mem_k'
module L = FStar.List.Tot
let lemma_seq_of_list_induction #_ l
= match l with
| [] -> ()
| hd::tl -> lemma_tl hd (seq_of_list tl)
let rec lemma_seq_list_bij': #a:Type -> s:seq a -> Lemma
(requires (True))
(ensures (seq_of_list (seq_to_list s) == s))
(decreases (length s))
= fun #_ s ->
let l = seq_to_list s in
lemma_seq_of_list_induction l;
if length s = 0 then (
assert (equal s (seq_of_list l))
)
else (
lemma_seq_list_bij' (slice s 1 (length s));
assert (equal s (seq_of_list (seq_to_list s)))
)
let lemma_seq_list_bij = lemma_seq_list_bij'
let rec lemma_list_seq_bij': #a:Type -> l:list a -> Lemma
(requires (True))
(ensures (seq_to_list (seq_of_list l) == l))
(decreases (L.length l))
= fun #_ l ->
lemma_seq_of_list_induction l;
if L.length l = 0 then ()
else (
lemma_list_seq_bij' (L.tl l);
assert(equal (seq_of_list (L.tl l)) (slice (seq_of_list l) 1 (length (seq_of_list l))))
)
let lemma_list_seq_bij = lemma_list_seq_bij'
let rec lemma_index_is_nth': #a:Type -> s:seq a -> i:nat{i < length s} -> Lemma
(requires True)
(ensures (L.index (seq_to_list s) i == index s i))
(decreases i)
= fun #_ s i ->
assert (s `equal` cons (head s) (tail s));
if i = 0 then ()
else (
lemma_index_is_nth' (slice s 1 (length s)) (i-1)
)
let lemma_index_is_nth = lemma_index_is_nth'
let contains #a s x =
exists (k:nat). k < Seq.length s /\ Seq.index s k == x
let contains_intro #_ _ _ _ = ()
let contains_elim #_ _ _ = ()
let lemma_contains_empty #_ = ()
let lemma_contains_singleton #_ _ = ()
private let intro_append_contains_from_disjunction (#a:Type) (s1:seq a) (s2:seq a) (x:a)
: Lemma (requires s1 `contains` x \/ s2 `contains` x)
(ensures (append s1 s2) `contains` x)
= let open FStar.Classical in
let open FStar.Squash in
or_elim #(s1 `contains` x) #(s2 `contains` x) #(fun _ -> (append s1 s2) `contains` x)
(fun _ -> ())
(fun _ -> let s = append s1 s2 in
exists_elim (s `contains` x) (get_proof (s2 `contains` x)) (fun k ->
assert (Seq.index s (Seq.length s1 + k) == x)))
let append_contains_equiv #_ s1 s2 x
= FStar.Classical.move_requires (intro_append_contains_from_disjunction s1 s2) x
let contains_snoc #_ s x =
FStar.Classical.forall_intro (append_contains_equiv s (Seq.create 1 x))
let rec lemma_find_l_contains' (#a:Type) (f:a -> Tot bool) (l:seq a)
: Lemma (requires True) (ensures Some? (find_l f l) ==> l `contains` (Some?.v (find_l f l)))
(decreases (Seq.length l))
= if length l = 0 then ()
else if f (head l) then ()
else lemma_find_l_contains' f (tail l)
let lemma_find_l_contains = lemma_find_l_contains'
let contains_cons #_ hd tl x
= append_contains_equiv (Seq.create 1 hd) tl x
let append_cons_snoc #_ _ _ _ = ()
let append_slices #_ _ _ = ()
let rec find_l_none_no_index' (#a:Type) (s:Seq.seq a) (f:(a -> Tot bool)) :
Lemma (requires (None? (find_l f s)))
(ensures (forall (i:nat{i < Seq.length s}). not (f (Seq.index s i))))
(decreases (Seq.length s))
= if Seq.length s = 0
then ()
else (assert (not (f (head s)));
assert (None? (find_l f (tail s)));
find_l_none_no_index' (tail s) f;
assert (Seq.equal s (cons (head s) (tail s)));
find_append_none (create 1 (head s)) (tail s) f)
let find_l_none_no_index = find_l_none_no_index'
let cons_head_tail #_ s =
let _ : squash (slice s 0 1 == create 1 (index s 0)) =
lemma_index_slice s 0 1 0;
lemma_index_create 1 (index s 0) 0;
lemma_eq_elim (slice s 0 1) (create 1 (index s 0))
in
lemma_split s 1
let head_cons #_ _ _ = ()
let suffix_of_tail #_ s = cons_head_tail s
let index_cons_l #_ _ _ = ()
let index_cons_r #_ _ _ _ = ()
let append_cons #_ c s1 s2 = lemma_eq_elim (append (cons c s1) s2) (cons c (append s1 s2))
let index_tail #_ _ _ = ()
let mem_cons #_ x s = lemma_append_count (create 1 x) s
let snoc_slice_index #_ s i j = lemma_eq_elim (snoc (slice s i j) (index s j)) (slice s i (j + 1))
let cons_index_slice #_ s i j _ = lemma_eq_elim (cons (index s i) (slice s (i + 1) j)) (slice s i j)
let slice_is_empty #_ s i = lemma_eq_elim (slice s i i) Seq.empty
let slice_length #_ s = lemma_eq_elim (slice s 0 (length s)) s
let slice_slice #_ s i1 j1 i2 j2 = lemma_eq_elim (slice (slice s i1 j1) i2 j2) (slice s (i1 + i2) (i1 + j2))
let rec lemma_seq_of_list_index #_ l i
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd::tl -> if i = 0 then () else lemma_seq_of_list_index tl (i - 1)
let seq_of_list_tl #_ l = lemma_seq_of_list_induction l
let rec mem_seq_of_list #_ x l
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| y :: q ->
let _ : squash (head (seq_of_list l) == y) = () in
let _ : squash (tail (seq_of_list l) == seq_of_list q) = seq_of_list_tl l in
let _ : squash (mem x (seq_of_list l) == (x = y || mem x (seq_of_list q))) =
lemma_mem_inversion (seq_of_list l)
in
mem_seq_of_list x q
let rec intro_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
explode_and i s l))
(ensures (
equal (seq_of_list l) (slice s i (length s))))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl -> intro_of_list'' (i + 1) s tl
let intro_of_list' = intro_of_list''
let intro_of_list #_ s l = intro_of_list' 0 s l
#push-options "--z3rlimit 20"
let rec elim_of_list'': #a:Type ->
i:nat ->
s:seq a ->
l:list a ->
Lemma
(requires (
List.Tot.length l + i = length s /\
i <= length s /\
slice s i (length s) == seq_of_list l))
(ensures (
explode_and i s l))
(decreases (
List.Tot.length l))
= fun #_ i s l ->
match l with
| [] -> ()
| hd :: tl ->
lemma_seq_of_list_induction l;
elim_of_list'' (i + 1) s tl
#pop-options
let elim_of_list' = elim_of_list'' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Seq.Properties.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"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 | l: Prims.list a
-> FStar.Pervasives.Lemma
(ensures
(let s = FStar.Seq.Base.seq_of_list l in
FStar.Seq.Properties.pointwise_and s l)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.Seq.Properties.elim_of_list'",
"FStar.Seq.Base.seq_of_list",
"Prims.unit"
] | [] | true | false | true | false | false | let elim_of_list #_ l =
| elim_of_list' 0 (seq_of_list l) l | false |
LowStar.Vector.fst | LowStar.Vector.loc_addr_of_vector | val loc_addr_of_vector: #a:Type -> vector a -> GTot loc | val loc_addr_of_vector: #a:Type -> vector a -> GTot loc | let loc_addr_of_vector #a vec =
B.loc_addr_of_buffer (Vec?.vs vec) | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 106,
"start_col": 0,
"start_line": 105
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a
val vector (a: Type0): Tot Type0
let vector a = vector_str a
/// Specification
val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)})
let as_seq h #a vec =
B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec))
/// Capacity
inline_for_extraction val size_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let size_of #a vec =
Vec?.sz vec
inline_for_extraction val capacity_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let capacity_of #a vec =
Vec?.cap vec
val is_empty: #a:Type -> vec:vector a -> Tot bool
let is_empty #a vec =
size_of vec = 0ul
val is_full: #a:Type -> vstr:vector_str a -> GTot bool
let is_full #a vstr =
Vec?.sz vstr >= max_uint32
/// Memory-related
val live: #a:Type -> HS.mem -> vector a -> GTot Type0
let live #a h vec =
B.live h (Vec?.vs vec)
val freeable: #a:Type -> vector a -> GTot Type0
let freeable #a vec =
B.freeable (Vec?.vs vec)
val loc_vector: #a:Type -> vector a -> GTot loc
let loc_vector #a vec =
B.loc_buffer (Vec?.vs vec) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 | vec: LowStar.Vector.vector a -> Prims.GTot LowStar.Monotonic.Buffer.loc | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Vector.vector",
"LowStar.Monotonic.Buffer.loc_addr_of_buffer",
"LowStar.Buffer.trivial_preorder",
"LowStar.Vector.__proj__Vec__item__vs",
"LowStar.Monotonic.Buffer.loc"
] | [] | false | false | false | false | false | let loc_addr_of_vector #a vec =
| B.loc_addr_of_buffer (Vec?.vs vec) | false |
LowStar.Vector.fst | LowStar.Vector.capacity_of | val capacity_of: #a:Type -> vec:vector a -> Tot uint32_t | val capacity_of: #a:Type -> vec:vector a -> Tot uint32_t | let capacity_of #a vec =
Vec?.cap vec | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 80,
"start_col": 22,
"start_line": 79
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a
val vector (a: Type0): Tot Type0
let vector a = vector_str a
/// Specification
val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)})
let as_seq h #a vec =
B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec))
/// Capacity
inline_for_extraction val size_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let size_of #a vec =
Vec?.sz vec | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 | vec: LowStar.Vector.vector a -> LowStar.Vector.uint32_t | Prims.Tot | [
"total"
] | [] | [
"LowStar.Vector.vector",
"LowStar.Vector.__proj__Vec__item__cap",
"LowStar.Vector.uint32_t"
] | [] | false | false | false | true | false | let capacity_of #a vec =
| Vec?.cap vec | false |
LowStar.Vector.fst | LowStar.Vector.frameOf | val frameOf: #a:Type -> vector a -> Tot HS.rid | val frameOf: #a:Type -> vector a -> Tot HS.rid | let frameOf #a vec =
B.frameOf (Vec?.vs vec) | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 213,
"start_col": 7,
"start_line": 212
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a
val vector (a: Type0): Tot Type0
let vector a = vector_str a
/// Specification
val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)})
let as_seq h #a vec =
B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec))
/// Capacity
inline_for_extraction val size_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let size_of #a vec =
Vec?.sz vec
inline_for_extraction val capacity_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let capacity_of #a vec =
Vec?.cap vec
val is_empty: #a:Type -> vec:vector a -> Tot bool
let is_empty #a vec =
size_of vec = 0ul
val is_full: #a:Type -> vstr:vector_str a -> GTot bool
let is_full #a vstr =
Vec?.sz vstr >= max_uint32
/// Memory-related
val live: #a:Type -> HS.mem -> vector a -> GTot Type0
let live #a h vec =
B.live h (Vec?.vs vec)
val freeable: #a:Type -> vector a -> GTot Type0
let freeable #a vec =
B.freeable (Vec?.vs vec)
val loc_vector: #a:Type -> vector a -> GTot loc
let loc_vector #a vec =
B.loc_buffer (Vec?.vs vec)
val loc_addr_of_vector: #a:Type -> vector a -> GTot loc
let loc_addr_of_vector #a vec =
B.loc_addr_of_buffer (Vec?.vs vec)
val loc_vector_within:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i <= j && j <= size_of vec} ->
GTot loc (decreases (U32.v (j - i)))
let rec loc_vector_within #a vec i j =
if i = j then loc_none
else loc_union (B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) j)
val loc_vector_within_includes_:
#a:Type -> vec:vector a ->
i:uint32_t ->
j1:uint32_t{i <= j1 && j1 <= size_of vec} ->
j2:uint32_t{i <= j2 && j2 <= j1} ->
Lemma (requires True)
(ensures (loc_includes (loc_vector_within vec i j1)
(loc_vector_within vec i j2)))
(decreases (U32.v (j1 - i)))
let rec loc_vector_within_includes_ #a vec i j1 j2 =
if i = j1 then ()
else if i = j2 then ()
else begin
loc_vector_within_includes_ vec (i + 1ul) j1 j2;
loc_includes_union_l (B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) j1)
(loc_vector_within vec (i + 1ul) j2);
loc_includes_union_r (loc_vector_within vec i j1)
(B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) j2)
end
val loc_vector_within_includes:
#a:Type -> vec:vector a ->
i1:uint32_t -> j1:uint32_t{i1 <= j1 && j1 <= size_of vec} ->
i2:uint32_t{i1 <= i2} -> j2:uint32_t{i2 <= j2 && j2 <= j1} ->
Lemma (requires True)
(ensures (loc_includes (loc_vector_within vec i1 j1)
(loc_vector_within vec i2 j2)))
(decreases (U32.v (j1 - i1)))
let rec loc_vector_within_includes #a vec i1 j1 i2 j2 =
if i1 = j1 then ()
else if i1 = i2 then loc_vector_within_includes_ vec i1 j1 j2
else begin
loc_vector_within_includes vec (i1 + 1ul) j1 i2 j2;
loc_includes_union_l (B.loc_buffer (B.gsub (Vec?.vs vec) i1 1ul))
(loc_vector_within vec (i1 + 1ul) j1)
(loc_vector_within vec i2 j2)
end
val loc_vector_within_included:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i <= j && j <= size_of vec} ->
Lemma (requires True)
(ensures (loc_includes (loc_vector vec)
(loc_vector_within vec i j)))
(decreases (U32.v (j - i)))
let rec loc_vector_within_included #a vec i j =
if i = j then ()
else loc_vector_within_included vec (i + 1ul) j
val loc_vector_within_disjoint_:
#a:Type -> vec:vector a ->
i1:uint32_t ->
i2:uint32_t{i1 < i2} ->
j2:uint32_t{i2 <= j2 && j2 <= size_of vec} ->
Lemma (requires True)
(ensures (loc_disjoint (B.loc_buffer (B.gsub (Vec?.vs vec) i1 1ul))
(loc_vector_within vec i2 j2)))
(decreases (U32.v (j2 - i2)))
let rec loc_vector_within_disjoint_ #a vec i1 i2 j2 =
if i2 = j2 then ()
else loc_vector_within_disjoint_ vec i1 (i2 + 1ul) j2
val loc_vector_within_disjoint:
#a:Type -> vec:vector a ->
i1:uint32_t -> j1:uint32_t{i1 <= j1 && j1 <= size_of vec} ->
i2:uint32_t{j1 <= i2} -> j2:uint32_t{i2 <= j2 && j2 <= size_of vec} ->
Lemma (requires True)
(ensures (loc_disjoint (loc_vector_within vec i1 j1)
(loc_vector_within vec i2 j2)))
(decreases (U32.v (j1 - i1)))
let rec loc_vector_within_disjoint #a vec i1 j1 i2 j2 =
if i1 = j1 then ()
else (loc_vector_within_disjoint_ vec i1 i2 j2;
loc_vector_within_disjoint vec (i1 + 1ul) j1 i2 j2)
val loc_vector_within_union_rev:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i < j && j <= size_of vec} ->
Lemma (requires True)
(ensures (loc_vector_within vec i j ==
loc_union (loc_vector_within vec i (j - 1ul))
(loc_vector_within vec (j - 1ul) j)))
(decreases (U32.v (j - i)))
let rec loc_vector_within_union_rev #a vec i j =
if i = j - 1ul then ()
else begin
loc_vector_within_union_rev vec (i + 1ul) j;
loc_union_assoc (B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) (j - 1ul))
(loc_vector_within vec (j - 1ul) j)
end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 | vec: LowStar.Vector.vector a -> FStar.Monotonic.HyperHeap.rid | Prims.Tot | [
"total"
] | [] | [
"LowStar.Vector.vector",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Buffer.trivial_preorder",
"LowStar.Vector.__proj__Vec__item__vs",
"FStar.Monotonic.HyperHeap.rid"
] | [] | false | false | false | true | false | let frameOf #a vec =
| B.frameOf (Vec?.vs vec) | false |
LowStar.Vector.fst | LowStar.Vector.loc_vector | val loc_vector: #a:Type -> vector a -> GTot loc | val loc_vector: #a:Type -> vector a -> GTot loc | let loc_vector #a vec =
B.loc_buffer (Vec?.vs vec) | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 102,
"start_col": 0,
"start_line": 101
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a
val vector (a: Type0): Tot Type0
let vector a = vector_str a
/// Specification
val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)})
let as_seq h #a vec =
B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec))
/// Capacity
inline_for_extraction val size_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let size_of #a vec =
Vec?.sz vec
inline_for_extraction val capacity_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let capacity_of #a vec =
Vec?.cap vec
val is_empty: #a:Type -> vec:vector a -> Tot bool
let is_empty #a vec =
size_of vec = 0ul
val is_full: #a:Type -> vstr:vector_str a -> GTot bool
let is_full #a vstr =
Vec?.sz vstr >= max_uint32
/// Memory-related
val live: #a:Type -> HS.mem -> vector a -> GTot Type0
let live #a h vec =
B.live h (Vec?.vs vec)
val freeable: #a:Type -> vector a -> GTot Type0
let freeable #a vec =
B.freeable (Vec?.vs vec) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 | vec: LowStar.Vector.vector a -> Prims.GTot LowStar.Monotonic.Buffer.loc | Prims.GTot | [
"sometrivial"
] | [] | [
"LowStar.Vector.vector",
"LowStar.Monotonic.Buffer.loc_buffer",
"LowStar.Buffer.trivial_preorder",
"LowStar.Vector.__proj__Vec__item__vs",
"LowStar.Monotonic.Buffer.loc"
] | [] | false | false | false | false | false | let loc_vector #a vec =
| B.loc_buffer (Vec?.vs vec) | false |
LowStar.Vector.fst | LowStar.Vector.hmap_dom_eq | val hmap_dom_eq: h0:HS.mem -> h1:HS.mem -> GTot Type0 | val hmap_dom_eq: h0:HS.mem -> h1:HS.mem -> GTot Type0 | let hmap_dom_eq h0 h1 =
Set.equal (Map.domain (HS.get_hmap h0))
(Map.domain (HS.get_hmap h1)) | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 218,
"start_col": 7,
"start_line": 216
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a
val vector (a: Type0): Tot Type0
let vector a = vector_str a
/// Specification
val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)})
let as_seq h #a vec =
B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec))
/// Capacity
inline_for_extraction val size_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let size_of #a vec =
Vec?.sz vec
inline_for_extraction val capacity_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let capacity_of #a vec =
Vec?.cap vec
val is_empty: #a:Type -> vec:vector a -> Tot bool
let is_empty #a vec =
size_of vec = 0ul
val is_full: #a:Type -> vstr:vector_str a -> GTot bool
let is_full #a vstr =
Vec?.sz vstr >= max_uint32
/// Memory-related
val live: #a:Type -> HS.mem -> vector a -> GTot Type0
let live #a h vec =
B.live h (Vec?.vs vec)
val freeable: #a:Type -> vector a -> GTot Type0
let freeable #a vec =
B.freeable (Vec?.vs vec)
val loc_vector: #a:Type -> vector a -> GTot loc
let loc_vector #a vec =
B.loc_buffer (Vec?.vs vec)
val loc_addr_of_vector: #a:Type -> vector a -> GTot loc
let loc_addr_of_vector #a vec =
B.loc_addr_of_buffer (Vec?.vs vec)
val loc_vector_within:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i <= j && j <= size_of vec} ->
GTot loc (decreases (U32.v (j - i)))
let rec loc_vector_within #a vec i j =
if i = j then loc_none
else loc_union (B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) j)
val loc_vector_within_includes_:
#a:Type -> vec:vector a ->
i:uint32_t ->
j1:uint32_t{i <= j1 && j1 <= size_of vec} ->
j2:uint32_t{i <= j2 && j2 <= j1} ->
Lemma (requires True)
(ensures (loc_includes (loc_vector_within vec i j1)
(loc_vector_within vec i j2)))
(decreases (U32.v (j1 - i)))
let rec loc_vector_within_includes_ #a vec i j1 j2 =
if i = j1 then ()
else if i = j2 then ()
else begin
loc_vector_within_includes_ vec (i + 1ul) j1 j2;
loc_includes_union_l (B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) j1)
(loc_vector_within vec (i + 1ul) j2);
loc_includes_union_r (loc_vector_within vec i j1)
(B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) j2)
end
val loc_vector_within_includes:
#a:Type -> vec:vector a ->
i1:uint32_t -> j1:uint32_t{i1 <= j1 && j1 <= size_of vec} ->
i2:uint32_t{i1 <= i2} -> j2:uint32_t{i2 <= j2 && j2 <= j1} ->
Lemma (requires True)
(ensures (loc_includes (loc_vector_within vec i1 j1)
(loc_vector_within vec i2 j2)))
(decreases (U32.v (j1 - i1)))
let rec loc_vector_within_includes #a vec i1 j1 i2 j2 =
if i1 = j1 then ()
else if i1 = i2 then loc_vector_within_includes_ vec i1 j1 j2
else begin
loc_vector_within_includes vec (i1 + 1ul) j1 i2 j2;
loc_includes_union_l (B.loc_buffer (B.gsub (Vec?.vs vec) i1 1ul))
(loc_vector_within vec (i1 + 1ul) j1)
(loc_vector_within vec i2 j2)
end
val loc_vector_within_included:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i <= j && j <= size_of vec} ->
Lemma (requires True)
(ensures (loc_includes (loc_vector vec)
(loc_vector_within vec i j)))
(decreases (U32.v (j - i)))
let rec loc_vector_within_included #a vec i j =
if i = j then ()
else loc_vector_within_included vec (i + 1ul) j
val loc_vector_within_disjoint_:
#a:Type -> vec:vector a ->
i1:uint32_t ->
i2:uint32_t{i1 < i2} ->
j2:uint32_t{i2 <= j2 && j2 <= size_of vec} ->
Lemma (requires True)
(ensures (loc_disjoint (B.loc_buffer (B.gsub (Vec?.vs vec) i1 1ul))
(loc_vector_within vec i2 j2)))
(decreases (U32.v (j2 - i2)))
let rec loc_vector_within_disjoint_ #a vec i1 i2 j2 =
if i2 = j2 then ()
else loc_vector_within_disjoint_ vec i1 (i2 + 1ul) j2
val loc_vector_within_disjoint:
#a:Type -> vec:vector a ->
i1:uint32_t -> j1:uint32_t{i1 <= j1 && j1 <= size_of vec} ->
i2:uint32_t{j1 <= i2} -> j2:uint32_t{i2 <= j2 && j2 <= size_of vec} ->
Lemma (requires True)
(ensures (loc_disjoint (loc_vector_within vec i1 j1)
(loc_vector_within vec i2 j2)))
(decreases (U32.v (j1 - i1)))
let rec loc_vector_within_disjoint #a vec i1 j1 i2 j2 =
if i1 = j1 then ()
else (loc_vector_within_disjoint_ vec i1 i2 j2;
loc_vector_within_disjoint vec (i1 + 1ul) j1 i2 j2)
val loc_vector_within_union_rev:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i < j && j <= size_of vec} ->
Lemma (requires True)
(ensures (loc_vector_within vec i j ==
loc_union (loc_vector_within vec i (j - 1ul))
(loc_vector_within vec (j - 1ul) j)))
(decreases (U32.v (j - i)))
let rec loc_vector_within_union_rev #a vec i j =
if i = j - 1ul then ()
else begin
loc_vector_within_union_rev vec (i + 1ul) j;
loc_union_assoc (B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) (j - 1ul))
(loc_vector_within vec (j - 1ul) j)
end
unfold val frameOf: #a:Type -> vector a -> Tot HS.rid
unfold let frameOf #a vec =
B.frameOf (Vec?.vs vec) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 | h0: FStar.Monotonic.HyperStack.mem -> h1: FStar.Monotonic.HyperStack.mem -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"FStar.Set.equal",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Map.domain",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap"
] | [] | false | false | false | false | true | let hmap_dom_eq h0 h1 =
| Set.equal (Map.domain (HS.get_hmap h0)) (Map.domain (HS.get_hmap h1)) | false |
LowStar.Vector.fst | LowStar.Vector.resize_ratio | val resize_ratio: uint32_t | val resize_ratio: uint32_t | let resize_ratio = 2ul | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 438,
"start_col": 8,
"start_line": 438
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a
val vector (a: Type0): Tot Type0
let vector a = vector_str a
/// Specification
val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)})
let as_seq h #a vec =
B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec))
/// Capacity
inline_for_extraction val size_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let size_of #a vec =
Vec?.sz vec
inline_for_extraction val capacity_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let capacity_of #a vec =
Vec?.cap vec
val is_empty: #a:Type -> vec:vector a -> Tot bool
let is_empty #a vec =
size_of vec = 0ul
val is_full: #a:Type -> vstr:vector_str a -> GTot bool
let is_full #a vstr =
Vec?.sz vstr >= max_uint32
/// Memory-related
val live: #a:Type -> HS.mem -> vector a -> GTot Type0
let live #a h vec =
B.live h (Vec?.vs vec)
val freeable: #a:Type -> vector a -> GTot Type0
let freeable #a vec =
B.freeable (Vec?.vs vec)
val loc_vector: #a:Type -> vector a -> GTot loc
let loc_vector #a vec =
B.loc_buffer (Vec?.vs vec)
val loc_addr_of_vector: #a:Type -> vector a -> GTot loc
let loc_addr_of_vector #a vec =
B.loc_addr_of_buffer (Vec?.vs vec)
val loc_vector_within:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i <= j && j <= size_of vec} ->
GTot loc (decreases (U32.v (j - i)))
let rec loc_vector_within #a vec i j =
if i = j then loc_none
else loc_union (B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) j)
val loc_vector_within_includes_:
#a:Type -> vec:vector a ->
i:uint32_t ->
j1:uint32_t{i <= j1 && j1 <= size_of vec} ->
j2:uint32_t{i <= j2 && j2 <= j1} ->
Lemma (requires True)
(ensures (loc_includes (loc_vector_within vec i j1)
(loc_vector_within vec i j2)))
(decreases (U32.v (j1 - i)))
let rec loc_vector_within_includes_ #a vec i j1 j2 =
if i = j1 then ()
else if i = j2 then ()
else begin
loc_vector_within_includes_ vec (i + 1ul) j1 j2;
loc_includes_union_l (B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) j1)
(loc_vector_within vec (i + 1ul) j2);
loc_includes_union_r (loc_vector_within vec i j1)
(B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) j2)
end
val loc_vector_within_includes:
#a:Type -> vec:vector a ->
i1:uint32_t -> j1:uint32_t{i1 <= j1 && j1 <= size_of vec} ->
i2:uint32_t{i1 <= i2} -> j2:uint32_t{i2 <= j2 && j2 <= j1} ->
Lemma (requires True)
(ensures (loc_includes (loc_vector_within vec i1 j1)
(loc_vector_within vec i2 j2)))
(decreases (U32.v (j1 - i1)))
let rec loc_vector_within_includes #a vec i1 j1 i2 j2 =
if i1 = j1 then ()
else if i1 = i2 then loc_vector_within_includes_ vec i1 j1 j2
else begin
loc_vector_within_includes vec (i1 + 1ul) j1 i2 j2;
loc_includes_union_l (B.loc_buffer (B.gsub (Vec?.vs vec) i1 1ul))
(loc_vector_within vec (i1 + 1ul) j1)
(loc_vector_within vec i2 j2)
end
val loc_vector_within_included:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i <= j && j <= size_of vec} ->
Lemma (requires True)
(ensures (loc_includes (loc_vector vec)
(loc_vector_within vec i j)))
(decreases (U32.v (j - i)))
let rec loc_vector_within_included #a vec i j =
if i = j then ()
else loc_vector_within_included vec (i + 1ul) j
val loc_vector_within_disjoint_:
#a:Type -> vec:vector a ->
i1:uint32_t ->
i2:uint32_t{i1 < i2} ->
j2:uint32_t{i2 <= j2 && j2 <= size_of vec} ->
Lemma (requires True)
(ensures (loc_disjoint (B.loc_buffer (B.gsub (Vec?.vs vec) i1 1ul))
(loc_vector_within vec i2 j2)))
(decreases (U32.v (j2 - i2)))
let rec loc_vector_within_disjoint_ #a vec i1 i2 j2 =
if i2 = j2 then ()
else loc_vector_within_disjoint_ vec i1 (i2 + 1ul) j2
val loc_vector_within_disjoint:
#a:Type -> vec:vector a ->
i1:uint32_t -> j1:uint32_t{i1 <= j1 && j1 <= size_of vec} ->
i2:uint32_t{j1 <= i2} -> j2:uint32_t{i2 <= j2 && j2 <= size_of vec} ->
Lemma (requires True)
(ensures (loc_disjoint (loc_vector_within vec i1 j1)
(loc_vector_within vec i2 j2)))
(decreases (U32.v (j1 - i1)))
let rec loc_vector_within_disjoint #a vec i1 j1 i2 j2 =
if i1 = j1 then ()
else (loc_vector_within_disjoint_ vec i1 i2 j2;
loc_vector_within_disjoint vec (i1 + 1ul) j1 i2 j2)
val loc_vector_within_union_rev:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i < j && j <= size_of vec} ->
Lemma (requires True)
(ensures (loc_vector_within vec i j ==
loc_union (loc_vector_within vec i (j - 1ul))
(loc_vector_within vec (j - 1ul) j)))
(decreases (U32.v (j - i)))
let rec loc_vector_within_union_rev #a vec i j =
if i = j - 1ul then ()
else begin
loc_vector_within_union_rev vec (i + 1ul) j;
loc_union_assoc (B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) (j - 1ul))
(loc_vector_within vec (j - 1ul) j)
end
unfold val frameOf: #a:Type -> vector a -> Tot HS.rid
unfold let frameOf #a vec =
B.frameOf (Vec?.vs vec)
unfold val hmap_dom_eq: h0:HS.mem -> h1:HS.mem -> GTot Type0
unfold let hmap_dom_eq h0 h1 =
Set.equal (Map.domain (HS.get_hmap h0))
(Map.domain (HS.get_hmap h1))
val modifies_as_seq:
#a:Type -> vec:vector a -> dloc:loc ->
h0:HS.mem -> h1:HS.mem ->
Lemma (requires (live h0 vec /\
loc_disjoint (loc_vector vec) dloc /\
modifies dloc h0 h1))
(ensures (live h1 vec /\
as_seq h0 vec == as_seq h1 vec))
[SMTPat (live h0 vec);
SMTPat (loc_disjoint (loc_vector vec) dloc);
SMTPat (modifies dloc h0 h1)]
let modifies_as_seq #a vec dloc h0 h1 =
B.modifies_buffer_elim (Vec?.vs vec) dloc h0 h1
val modifies_as_seq_within:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i <= j && j <= size_of vec} ->
dloc:loc -> h0:HS.mem -> h1:HS.mem ->
Lemma (requires (live h0 vec /\
loc_disjoint (loc_vector_within vec i j) dloc /\
modifies dloc h0 h1))
(ensures (S.slice (as_seq h0 vec) (U32.v i) (U32.v j) ==
S.slice (as_seq h1 vec) (U32.v i) (U32.v j)))
(decreases (U32.v (j - i)))
[SMTPat (live h0 vec);
SMTPat (loc_disjoint (loc_vector_within vec i j) dloc);
SMTPat (modifies dloc h0 h1)]
let rec modifies_as_seq_within #a vec i j dloc h0 h1 =
if i = j then ()
else begin
B.modifies_buffer_elim (B.gsub (Vec?.vs vec) i 1ul) dloc h0 h1;
modifies_as_seq_within vec (i + 1ul) j dloc h0 h1;
assert (S.equal (S.slice (as_seq h0 vec) (U32.v i) (U32.v j))
(S.append (S.slice (as_seq h0 vec) (U32.v i) (U32.v i + 1))
(S.slice (as_seq h0 vec) (U32.v i + 1) (U32.v j))));
assert (S.equal (S.slice (as_seq h1 vec) (U32.v i) (U32.v j))
(S.append (S.slice (as_seq h1 vec) (U32.v i) (U32.v i + 1))
(S.slice (as_seq h1 vec) (U32.v i + 1) (U32.v j))))
end
/// Construction
inline_for_extraction val alloc_empty:
a:Type -> Tot (vec:vector a{size_of vec = 0ul})
inline_for_extraction let alloc_empty a =
Vec 0ul 0ul B.null
val alloc_empty_as_seq_empty:
a:Type -> h:HS.mem ->
Lemma (S.equal (as_seq h (alloc_empty a)) S.empty)
[SMTPat (as_seq h (alloc_empty a))]
let alloc_empty_as_seq_empty a h = ()
val alloc_rid:
#a:Type -> len:uint32_t{len > 0ul} -> v:a ->
rid:HS.rid{HST.is_eternal_region rid} ->
HST.ST (vector a)
(requires (fun h0 -> true))
(ensures (fun h0 vec h1 ->
frameOf vec = rid /\
live h1 vec /\ freeable vec /\
modifies loc_none h0 h1 /\
Set.equal (Map.domain (HS.get_hmap h0))
(Map.domain (HS.get_hmap h1)) /\
size_of vec = len /\
S.equal (as_seq h1 vec) (S.create (U32.v len) v) /\
B.fresh_loc (loc_vector vec) h0 h1))
let alloc_rid #a len v rid =
Vec len len (B.malloc rid v len)
// Allocate a vector with the length `len`, filled with the initial value `v`.
// Note that the vector is allocated in the root region.
val alloc:
#a:Type -> len:uint32_t{len > 0ul} -> v:a ->
HST.ST (vector a)
(requires (fun h0 -> true))
(ensures (fun h0 vec h1 ->
frameOf vec = HS.root /\
live h1 vec /\ freeable vec /\
modifies loc_none h0 h1 /\
Set.equal (Map.domain (HS.get_hmap h0))
(Map.domain (HS.get_hmap h1)) /\
size_of vec = len /\
S.equal (as_seq h1 vec) (S.create (U32.v len) v) /\
B.fresh_loc (loc_vector vec) h0 h1))
let alloc #a len v =
alloc_rid len v HS.root
// Allocate a vector with the _capacity_ `len`; we still need to provide an
// initial value `ia` in order to allocate space.
val alloc_reserve:
#a:Type -> len:uint32_t{len > 0ul} -> ia:a ->
rid:HS.rid{HST.is_eternal_region rid} ->
HST.ST (vector a)
(requires (fun h0 -> true))
(ensures (fun h0 vec h1 ->
frameOf vec = rid /\ live h1 vec /\ freeable vec /\
modifies loc_none h0 h1 /\
B.fresh_loc (loc_vector vec) h0 h1 /\
Set.equal (Map.domain (HS.get_hmap h0))
(Map.domain (HS.get_hmap h1)) /\
size_of vec = 0ul /\
S.equal (as_seq h1 vec) S.empty))
let alloc_reserve #a len ia rid =
Vec 0ul len (B.malloc rid ia len)
// Allocate a vector with a given buffer with the length `len`.
// Note that it does not copy the buffer content; instead it directly uses the
// buffer pointer.
val alloc_by_buffer:
#a:Type -> len:uint32_t{len > 0ul} ->
buf:B.buffer a{B.len buf = len} ->
HST.ST (vector a)
(requires (fun h0 -> B.live h0 buf))
(ensures (fun h0 vec h1 ->
frameOf vec = B.frameOf buf /\ loc_vector vec == B.loc_buffer buf /\
live h1 vec /\ h0 == h1 /\
size_of vec = len /\
S.equal (as_seq h1 vec) (B.as_seq h0 buf)))
let alloc_by_buffer #a len buf =
Vec len len buf
/// Destruction
val free:
#a:Type -> vec:vector a ->
HST.ST unit
(requires (fun h0 -> live h0 vec /\ freeable vec))
(ensures (fun h0 _ h1 -> modifies (loc_addr_of_vector vec) h0 h1))
let free #a vec =
B.free (Vec?.vs vec)
/// Element access
val get:
#a:Type -> h:HS.mem -> vec:vector a ->
i:uint32_t{i < size_of vec} -> GTot a
let get #a h vec i =
S.index (as_seq h vec) (U32.v i)
val index:
#a:Type -> vec:vector a -> i:uint32_t ->
HST.ST a
(requires (fun h0 -> live h0 vec /\ i < size_of vec))
(ensures (fun h0 v h1 ->
h0 == h1 /\ S.index (as_seq h1 vec) (U32.v i) == v))
let index #a vec i =
B.index (Vec?.vs vec) i
val front:
#a:Type -> vec:vector a{size_of vec > 0ul} ->
HST.ST a
(requires (fun h0 -> live h0 vec))
(ensures (fun h0 v h1 ->
h0 == h1 /\ S.index (as_seq h1 vec) 0 == v))
let front #a vec =
B.index (Vec?.vs vec) 0ul
val back:
#a:Type -> vec:vector a{size_of vec > 0ul} ->
HST.ST a
(requires (fun h0 -> live h0 vec))
(ensures (fun h0 v h1 ->
h0 == h1 /\ S.index (as_seq h1 vec) (U32.v (size_of vec) - 1) == v))
let back #a vec =
B.index (Vec?.vs vec) (size_of vec - 1ul)
/// Operations
val clear:
#a:Type -> vec:vector a ->
Tot (cvec:vector a{size_of cvec = 0ul})
let clear #a vec =
Vec 0ul (Vec?.cap vec) (Vec?.vs vec)
val clear_as_seq_empty:
#a:Type -> h:HS.mem -> vec:vector a ->
Lemma (S.equal (as_seq h (clear vec)) S.empty)
[SMTPat (as_seq h (clear vec))]
let clear_as_seq_empty #a h vec = ()
private val slice_append:
#a:Type -> s:S.seq a ->
i:nat -> j:nat{i <= j} -> k:nat{j <= k && k <= S.length s} ->
Lemma (S.equal (S.slice s i k)
(S.append (S.slice s i j) (S.slice s j k)))
private let slice_append #a s i j k = ()
val assign:
#a:Type -> vec:vector a ->
i:uint32_t -> v:a ->
HST.ST unit
(requires (fun h0 -> live h0 vec /\ i < size_of vec))
(ensures (fun h0 _ h1 ->
hmap_dom_eq h0 h1 /\
modifies (loc_vector_within #a vec i (i + 1ul)) h0 h1 /\
get h1 vec i == v /\
S.equal (as_seq h1 vec) (S.upd (as_seq h0 vec) (U32.v i) v) /\
live h1 vec))
#reset-options "--z3rlimit 10"
let assign #a vec i v =
let hh0 = HST.get () in
// NOTE: `B.upd (Vec?.vs vec) i v` makes more sense,
// but the `modifies` postcondition is coarse-grained.
B.upd (B.sub (Vec?.vs vec) i 1ul) 0ul v;
let hh1 = HST.get () in
loc_vector_within_disjoint vec 0ul i i (i + 1ul);
modifies_as_seq_within
vec 0ul i (loc_vector_within #a vec i (i + 1ul)) hh0 hh1;
loc_vector_within_disjoint vec i (i + 1ul) (i + 1ul) (size_of vec);
modifies_as_seq_within
vec (i + 1ul) (size_of vec) (loc_vector_within #a vec i (i + 1ul)) hh0 hh1;
slice_append (as_seq hh1 vec) 0 (U32.v i) (U32.v i + 1);
slice_append (as_seq hh1 vec) 0 (U32.v i + 1) (U32.v (size_of vec));
slice_append (S.upd (as_seq hh0 vec) (U32.v i) v) 0 (U32.v i) (U32.v i + 1);
slice_append (S.upd (as_seq hh0 vec) (U32.v i) v) 0 (U32.v i + 1) (U32.v (size_of vec)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | LowStar.Vector.uint32_t | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.__uint_to_t"
] | [] | false | false | false | true | false | let resize_ratio =
| 2ul | false |
LowStar.Vector.fst | LowStar.Vector.as_seq | val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)}) | val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)}) | let as_seq h #a vec =
B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec)) | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 70,
"start_col": 0,
"start_line": 69
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a
val vector (a: Type0): Tot Type0
let vector a = vector_str a
/// Specification
val as_seq:
HS.mem -> #a:Type -> vec:vector a -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 | h: FStar.Monotonic.HyperStack.mem -> vec: LowStar.Vector.vector a
-> Prims.GTot (s: FStar.Seq.Base.seq a {FStar.Seq.Base.length s = FStar.UInt32.v (Vec?.sz vec)}) | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"LowStar.Vector.vector",
"LowStar.Monotonic.Buffer.as_seq",
"LowStar.Buffer.trivial_preorder",
"LowStar.Buffer.gsub",
"LowStar.Vector.__proj__Vec__item__vs",
"FStar.UInt32.__uint_to_t",
"LowStar.Vector.__proj__Vec__item__sz",
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"FStar.Seq.Base.length",
"FStar.UInt32.v"
] | [] | false | false | false | false | false | let as_seq h #a vec =
| B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec)) | false |
Vale.Transformers.Locations.fst | Vale.Transformers.Locations.disjoint_location | val disjoint_location : location -> location -> pbool | val disjoint_location : location -> location -> pbool | let disjoint_location a1 a2 =
match a1, a2 with
| ALocCf, ALocCf -> ffalse "carry flag not disjoint from itself"
| ALocOf, ALocOf -> ffalse "overflow flag not disjoint from itself"
| ALocCf, _ | ALocOf, _ | _, ALocCf | _, ALocOf -> ttrue
| ALocMem, ALocMem -> ffalse "memory not disjoint from itself"
| ALocStack, ALocStack -> ffalse "stack not disjoint from itself"
| ALocMem, ALocStack | ALocStack, ALocMem -> ttrue
| ALocReg r1, ALocReg r2 ->
(r1 <> r2) /- ("register " ^ aux_print_reg_from_location a1 ^ " not disjoint from itself")
| ALocReg _, _ | _, ALocReg _ -> ttrue | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.Locations.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 40,
"end_line": 41,
"start_col": 0,
"start_line": 31
} | module Vale.Transformers.Locations
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Bytes_Code_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Machine_s
open Vale.X64.Print_s
open Vale.Def.PossiblyMonad
module L = FStar.List.Tot
(* See fsti *)
type location : eqtype =
| ALocMem : location
| ALocStack: location
| ALocReg : reg -> location
| ALocCf : location
| ALocOf : location
let aux_print_reg_from_location (a:location{ALocReg? a}) : string =
let ALocReg (Reg file id) = a in
match file with
| 0 -> print_reg_name id
| 1 -> print_xmm id gcc | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Def.PossiblyMonad.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Transformers.Locations.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Def.PossiblyMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Def.PossiblyMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"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": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a1: Vale.Transformers.Locations.location -> a2: Vale.Transformers.Locations.location
-> Vale.Def.PossiblyMonad.pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.Transformers.Locations.location",
"FStar.Pervasives.Native.Mktuple2",
"Vale.Def.PossiblyMonad.ffalse",
"Vale.Def.PossiblyMonad.ttrue",
"Vale.X64.Machine_s.reg",
"Vale.Def.PossiblyMonad.op_Slash_Subtraction",
"Prims.op_disEquality",
"Prims.op_Hat",
"Vale.Transformers.Locations.aux_print_reg_from_location",
"Vale.Def.PossiblyMonad.pbool"
] | [] | false | false | false | true | false | let disjoint_location a1 a2 =
| match a1, a2 with
| ALocCf, ALocCf -> ffalse "carry flag not disjoint from itself"
| ALocOf, ALocOf -> ffalse "overflow flag not disjoint from itself"
| ALocCf, _ | ALocOf, _ | _, ALocCf | _, ALocOf -> ttrue
| ALocMem, ALocMem -> ffalse "memory not disjoint from itself"
| ALocStack, ALocStack -> ffalse "stack not disjoint from itself"
| ALocMem, ALocStack | ALocStack, ALocMem -> ttrue
| ALocReg r1, ALocReg r2 ->
(r1 <> r2) /- ("register " ^ aux_print_reg_from_location a1 ^ " not disjoint from itself")
| ALocReg _, _ | _, ALocReg _ -> ttrue | false |
LowStar.Vector.fst | LowStar.Vector.alloc_rid | val alloc_rid:
#a:Type -> len:uint32_t{len > 0ul} -> v:a ->
rid:HS.rid{HST.is_eternal_region rid} ->
HST.ST (vector a)
(requires (fun h0 -> true))
(ensures (fun h0 vec h1 ->
frameOf vec = rid /\
live h1 vec /\ freeable vec /\
modifies loc_none h0 h1 /\
Set.equal (Map.domain (HS.get_hmap h0))
(Map.domain (HS.get_hmap h1)) /\
size_of vec = len /\
S.equal (as_seq h1 vec) (S.create (U32.v len) v) /\
B.fresh_loc (loc_vector vec) h0 h1)) | val alloc_rid:
#a:Type -> len:uint32_t{len > 0ul} -> v:a ->
rid:HS.rid{HST.is_eternal_region rid} ->
HST.ST (vector a)
(requires (fun h0 -> true))
(ensures (fun h0 vec h1 ->
frameOf vec = rid /\
live h1 vec /\ freeable vec /\
modifies loc_none h0 h1 /\
Set.equal (Map.domain (HS.get_hmap h0))
(Map.domain (HS.get_hmap h1)) /\
size_of vec = len /\
S.equal (as_seq h1 vec) (S.create (U32.v len) v) /\
B.fresh_loc (loc_vector vec) h0 h1)) | let alloc_rid #a len v rid =
Vec len len (B.malloc rid v len) | {
"file_name": "ulib/LowStar.Vector.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 288,
"start_col": 0,
"start_line": 287
} | (*
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 LowStar.Vector
(**
* This module provides support for mutable, partially filled arrays
* whose contents may grow up to some fixed capacity determined
* during initialization.
*
* Vectors support an insertion operation that may, if the capacity
* has been reached, involve copying its contents to a new
* vector of twice the capacity (so long as the capacity has not
* already reached max_uint32).
*
* Conversely, an operation called `flush` is also provided to
* shrink a vector to some prefix of its current contents.
*
* Other operations are fairly standard, and involve reading,
* writing, and iterating over a vector.
*
*)
open FStar.Integers
open LowStar.Modifies
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = FStar.Seq
type uint32_t = UInt32.t
val max_uint32: uint32_t
let max_uint32 = 4294967295ul // UInt32.uint_to_t (UInt.max_int UInt32.n)
module U32 = FStar.UInt32
/// Abstract vector type
inline_for_extraction noeq type vector_str a =
| Vec: sz:uint32_t ->
cap:uint32_t{cap >= sz} ->
vs:B.buffer a{B.len vs = cap} ->
vector_str a
val vector (a: Type0): Tot Type0
let vector a = vector_str a
/// Specification
val as_seq:
HS.mem -> #a:Type -> vec:vector a ->
GTot (s:S.seq a{S.length s = U32.v (Vec?.sz vec)})
let as_seq h #a vec =
B.as_seq h (B.gsub (Vec?.vs vec) 0ul (Vec?.sz vec))
/// Capacity
inline_for_extraction val size_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let size_of #a vec =
Vec?.sz vec
inline_for_extraction val capacity_of: #a:Type -> vec:vector a -> Tot uint32_t
inline_for_extraction let capacity_of #a vec =
Vec?.cap vec
val is_empty: #a:Type -> vec:vector a -> Tot bool
let is_empty #a vec =
size_of vec = 0ul
val is_full: #a:Type -> vstr:vector_str a -> GTot bool
let is_full #a vstr =
Vec?.sz vstr >= max_uint32
/// Memory-related
val live: #a:Type -> HS.mem -> vector a -> GTot Type0
let live #a h vec =
B.live h (Vec?.vs vec)
val freeable: #a:Type -> vector a -> GTot Type0
let freeable #a vec =
B.freeable (Vec?.vs vec)
val loc_vector: #a:Type -> vector a -> GTot loc
let loc_vector #a vec =
B.loc_buffer (Vec?.vs vec)
val loc_addr_of_vector: #a:Type -> vector a -> GTot loc
let loc_addr_of_vector #a vec =
B.loc_addr_of_buffer (Vec?.vs vec)
val loc_vector_within:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i <= j && j <= size_of vec} ->
GTot loc (decreases (U32.v (j - i)))
let rec loc_vector_within #a vec i j =
if i = j then loc_none
else loc_union (B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) j)
val loc_vector_within_includes_:
#a:Type -> vec:vector a ->
i:uint32_t ->
j1:uint32_t{i <= j1 && j1 <= size_of vec} ->
j2:uint32_t{i <= j2 && j2 <= j1} ->
Lemma (requires True)
(ensures (loc_includes (loc_vector_within vec i j1)
(loc_vector_within vec i j2)))
(decreases (U32.v (j1 - i)))
let rec loc_vector_within_includes_ #a vec i j1 j2 =
if i = j1 then ()
else if i = j2 then ()
else begin
loc_vector_within_includes_ vec (i + 1ul) j1 j2;
loc_includes_union_l (B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) j1)
(loc_vector_within vec (i + 1ul) j2);
loc_includes_union_r (loc_vector_within vec i j1)
(B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) j2)
end
val loc_vector_within_includes:
#a:Type -> vec:vector a ->
i1:uint32_t -> j1:uint32_t{i1 <= j1 && j1 <= size_of vec} ->
i2:uint32_t{i1 <= i2} -> j2:uint32_t{i2 <= j2 && j2 <= j1} ->
Lemma (requires True)
(ensures (loc_includes (loc_vector_within vec i1 j1)
(loc_vector_within vec i2 j2)))
(decreases (U32.v (j1 - i1)))
let rec loc_vector_within_includes #a vec i1 j1 i2 j2 =
if i1 = j1 then ()
else if i1 = i2 then loc_vector_within_includes_ vec i1 j1 j2
else begin
loc_vector_within_includes vec (i1 + 1ul) j1 i2 j2;
loc_includes_union_l (B.loc_buffer (B.gsub (Vec?.vs vec) i1 1ul))
(loc_vector_within vec (i1 + 1ul) j1)
(loc_vector_within vec i2 j2)
end
val loc_vector_within_included:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i <= j && j <= size_of vec} ->
Lemma (requires True)
(ensures (loc_includes (loc_vector vec)
(loc_vector_within vec i j)))
(decreases (U32.v (j - i)))
let rec loc_vector_within_included #a vec i j =
if i = j then ()
else loc_vector_within_included vec (i + 1ul) j
val loc_vector_within_disjoint_:
#a:Type -> vec:vector a ->
i1:uint32_t ->
i2:uint32_t{i1 < i2} ->
j2:uint32_t{i2 <= j2 && j2 <= size_of vec} ->
Lemma (requires True)
(ensures (loc_disjoint (B.loc_buffer (B.gsub (Vec?.vs vec) i1 1ul))
(loc_vector_within vec i2 j2)))
(decreases (U32.v (j2 - i2)))
let rec loc_vector_within_disjoint_ #a vec i1 i2 j2 =
if i2 = j2 then ()
else loc_vector_within_disjoint_ vec i1 (i2 + 1ul) j2
val loc_vector_within_disjoint:
#a:Type -> vec:vector a ->
i1:uint32_t -> j1:uint32_t{i1 <= j1 && j1 <= size_of vec} ->
i2:uint32_t{j1 <= i2} -> j2:uint32_t{i2 <= j2 && j2 <= size_of vec} ->
Lemma (requires True)
(ensures (loc_disjoint (loc_vector_within vec i1 j1)
(loc_vector_within vec i2 j2)))
(decreases (U32.v (j1 - i1)))
let rec loc_vector_within_disjoint #a vec i1 j1 i2 j2 =
if i1 = j1 then ()
else (loc_vector_within_disjoint_ vec i1 i2 j2;
loc_vector_within_disjoint vec (i1 + 1ul) j1 i2 j2)
val loc_vector_within_union_rev:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i < j && j <= size_of vec} ->
Lemma (requires True)
(ensures (loc_vector_within vec i j ==
loc_union (loc_vector_within vec i (j - 1ul))
(loc_vector_within vec (j - 1ul) j)))
(decreases (U32.v (j - i)))
let rec loc_vector_within_union_rev #a vec i j =
if i = j - 1ul then ()
else begin
loc_vector_within_union_rev vec (i + 1ul) j;
loc_union_assoc (B.loc_buffer (B.gsub (Vec?.vs vec) i 1ul))
(loc_vector_within vec (i + 1ul) (j - 1ul))
(loc_vector_within vec (j - 1ul) j)
end
unfold val frameOf: #a:Type -> vector a -> Tot HS.rid
unfold let frameOf #a vec =
B.frameOf (Vec?.vs vec)
unfold val hmap_dom_eq: h0:HS.mem -> h1:HS.mem -> GTot Type0
unfold let hmap_dom_eq h0 h1 =
Set.equal (Map.domain (HS.get_hmap h0))
(Map.domain (HS.get_hmap h1))
val modifies_as_seq:
#a:Type -> vec:vector a -> dloc:loc ->
h0:HS.mem -> h1:HS.mem ->
Lemma (requires (live h0 vec /\
loc_disjoint (loc_vector vec) dloc /\
modifies dloc h0 h1))
(ensures (live h1 vec /\
as_seq h0 vec == as_seq h1 vec))
[SMTPat (live h0 vec);
SMTPat (loc_disjoint (loc_vector vec) dloc);
SMTPat (modifies dloc h0 h1)]
let modifies_as_seq #a vec dloc h0 h1 =
B.modifies_buffer_elim (Vec?.vs vec) dloc h0 h1
val modifies_as_seq_within:
#a:Type -> vec:vector a ->
i:uint32_t -> j:uint32_t{i <= j && j <= size_of vec} ->
dloc:loc -> h0:HS.mem -> h1:HS.mem ->
Lemma (requires (live h0 vec /\
loc_disjoint (loc_vector_within vec i j) dloc /\
modifies dloc h0 h1))
(ensures (S.slice (as_seq h0 vec) (U32.v i) (U32.v j) ==
S.slice (as_seq h1 vec) (U32.v i) (U32.v j)))
(decreases (U32.v (j - i)))
[SMTPat (live h0 vec);
SMTPat (loc_disjoint (loc_vector_within vec i j) dloc);
SMTPat (modifies dloc h0 h1)]
let rec modifies_as_seq_within #a vec i j dloc h0 h1 =
if i = j then ()
else begin
B.modifies_buffer_elim (B.gsub (Vec?.vs vec) i 1ul) dloc h0 h1;
modifies_as_seq_within vec (i + 1ul) j dloc h0 h1;
assert (S.equal (S.slice (as_seq h0 vec) (U32.v i) (U32.v j))
(S.append (S.slice (as_seq h0 vec) (U32.v i) (U32.v i + 1))
(S.slice (as_seq h0 vec) (U32.v i + 1) (U32.v j))));
assert (S.equal (S.slice (as_seq h1 vec) (U32.v i) (U32.v j))
(S.append (S.slice (as_seq h1 vec) (U32.v i) (U32.v i + 1))
(S.slice (as_seq h1 vec) (U32.v i + 1) (U32.v j))))
end
/// Construction
inline_for_extraction val alloc_empty:
a:Type -> Tot (vec:vector a{size_of vec = 0ul})
inline_for_extraction let alloc_empty a =
Vec 0ul 0ul B.null
val alloc_empty_as_seq_empty:
a:Type -> h:HS.mem ->
Lemma (S.equal (as_seq h (alloc_empty a)) S.empty)
[SMTPat (as_seq h (alloc_empty a))]
let alloc_empty_as_seq_empty a h = ()
val alloc_rid:
#a:Type -> len:uint32_t{len > 0ul} -> v:a ->
rid:HS.rid{HST.is_eternal_region rid} ->
HST.ST (vector a)
(requires (fun h0 -> true))
(ensures (fun h0 vec h1 ->
frameOf vec = rid /\
live h1 vec /\ freeable vec /\
modifies loc_none h0 h1 /\
Set.equal (Map.domain (HS.get_hmap h0))
(Map.domain (HS.get_hmap h1)) /\
size_of vec = len /\
S.equal (as_seq h1 vec) (S.create (U32.v len) v) /\ | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Modifies.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Integers.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "LowStar.Vector.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.Modifies",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Integers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar",
"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 |
len: LowStar.Vector.uint32_t{len > 0ul} ->
v: a ->
rid: FStar.Monotonic.HyperHeap.rid{FStar.HyperStack.ST.is_eternal_region rid}
-> FStar.HyperStack.ST.ST (LowStar.Vector.vector a) | FStar.HyperStack.ST.ST | [] | [] | [
"LowStar.Vector.uint32_t",
"Prims.b2t",
"FStar.Integers.op_Greater",
"FStar.Integers.Unsigned",
"FStar.Integers.W32",
"FStar.UInt32.__uint_to_t",
"FStar.Monotonic.HyperHeap.rid",
"FStar.HyperStack.ST.is_eternal_region",
"LowStar.Vector.Vec",
"LowStar.Vector.vector",
"LowStar.Buffer.buffer",
"Prims.op_Equality",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.len",
"LowStar.Buffer.trivial_preorder",
"LowStar.Buffer.malloc",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.UInt32.v",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.freeable"
] | [] | false | true | false | false | false | let alloc_rid #a len v rid =
| Vec len len (B.malloc rid v len) | false |
Vale.Transformers.Locations.fst | Vale.Transformers.Locations.location_val_t | val location_val_t : location -> Type u#1 | val location_val_t : location -> Type u#1 | let location_val_t a =
match a with
| ALocMem -> heap_impl
| ALocStack -> FStar.Universe.raise_t (machine_stack & memTaint_t)
| ALocReg r -> FStar.Universe.raise_t (t_reg r)
| ALocCf -> FStar.Universe.raise_t flag_val_t
| ALocOf -> FStar.Universe.raise_t flag_val_t | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.Locations.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 47,
"end_line": 56,
"start_col": 0,
"start_line": 50
} | module Vale.Transformers.Locations
open Vale.Arch.HeapTypes_s
open Vale.Arch.Heap
open Vale.X64.Bytes_Code_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Machine_s
open Vale.X64.Print_s
open Vale.Def.PossiblyMonad
module L = FStar.List.Tot
(* See fsti *)
type location : eqtype =
| ALocMem : location
| ALocStack: location
| ALocReg : reg -> location
| ALocCf : location
| ALocOf : location
let aux_print_reg_from_location (a:location{ALocReg? a}) : string =
let ALocReg (Reg file id) = a in
match file with
| 0 -> print_reg_name id
| 1 -> print_xmm id gcc
(* See fsti *)
let disjoint_location a1 a2 =
match a1, a2 with
| ALocCf, ALocCf -> ffalse "carry flag not disjoint from itself"
| ALocOf, ALocOf -> ffalse "overflow flag not disjoint from itself"
| ALocCf, _ | ALocOf, _ | _, ALocCf | _, ALocOf -> ttrue
| ALocMem, ALocMem -> ffalse "memory not disjoint from itself"
| ALocStack, ALocStack -> ffalse "stack not disjoint from itself"
| ALocMem, ALocStack | ALocStack, ALocMem -> ttrue
| ALocReg r1, ALocReg r2 ->
(r1 <> r2) /- ("register " ^ aux_print_reg_from_location a1 ^ " not disjoint from itself")
| ALocReg _, _ | _, ALocReg _ -> ttrue
(* See fsti *)
let auto_lemma_disjoint_location a1 a2 = ()
(* See fsti *)
let downgrade_val_raise_val_u0_u1 #a x = FStar.Universe.downgrade_val_raise_val #a x | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Def.PossiblyMonad.fst.checked",
"Vale.Arch.HeapTypes_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Transformers.Locations.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Def.PossiblyMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapTypes_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Vale.Def.PossiblyMonad",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"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": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Vale.Transformers.Locations.location -> Type | Prims.Tot | [
"total"
] | [] | [
"Vale.Transformers.Locations.location",
"Vale.Arch.Heap.heap_impl",
"FStar.Universe.raise_t",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.Machine_Semantics_s.machine_stack",
"Vale.Arch.HeapTypes_s.memTaint_t",
"Vale.X64.Machine_s.reg",
"Vale.X64.Machine_s.t_reg",
"Vale.X64.Machine_Semantics_s.flag_val_t"
] | [] | false | false | false | true | true | let location_val_t a =
| match a with
| ALocMem -> heap_impl
| ALocStack -> FStar.Universe.raise_t (machine_stack & memTaint_t)
| ALocReg r -> FStar.Universe.raise_t (t_reg r)
| ALocCf -> FStar.Universe.raise_t flag_val_t
| ALocOf -> FStar.Universe.raise_t flag_val_t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.