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.Matrix.fst | FStar.Matrix.foldm_snoc_distributivity_left | val foldm_snoc_distributivity_left (#c #eq: _) (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a (SP.foldm_snoc add s)) `eq.eq` (SP.foldm_snoc add (const_op_seq mul a s))
)
(decreases SB.length s) | val foldm_snoc_distributivity_left (#c #eq: _) (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a (SP.foldm_snoc add s)) `eq.eq` (SP.foldm_snoc add (const_op_seq mul a s))
)
(decreases SB.length s) | let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 79,
"end_line": 553,
"start_col": 0,
"start_line": 539
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
a: c ->
s: FStar.Seq.Base.seq c
-> FStar.Pervasives.Lemma
(requires
FStar.Matrix.is_fully_distributive mul add /\ FStar.Matrix.is_absorber (CM?.unit add) mul)
(ensures
EQ?.eq eq
(CM?.mult mul a (FStar.Seq.Permutation.foldm_snoc add s))
(FStar.Seq.Permutation.foldm_snoc add (FStar.Matrix.const_op_seq mul a s)))
(decreases FStar.Seq.Base.length s) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Matrix.const_op_seq",
"FStar.Matrix.foldm_snoc_distributivity_left",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.Mktuple3",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"Prims.bool",
"Prims.l_and",
"FStar.Matrix.is_fully_distributive",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec foldm_snoc_distributivity_left
#c
#eq
(mul: CE.cm c eq)
(add: CE.cm c eq)
(a: c)
(s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a (SP.foldm_snoc add s)) `eq.eq` (SP.foldm_snoc add (const_op_seq mul a s))
)
(decreases SB.length s) =
| if SB.length s > 0
then
let ( + ), ( * ), ( = ) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a * sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a * sum s) (rhs_last + a * sum liat) (rhs_last + sum rhs_liat) | false |
Demo.Deps.fst | Demo.Deps.buffer | val buffer : a: Type0 -> Type0 | let buffer = B.buffer | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 26,
"start_col": 0,
"start_line": 26
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": 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.Buffer.buffer"
] | [] | false | false | false | true | true | let buffer =
| B.buffer | false |
|
FStar.Matrix.fst | FStar.Matrix.terminal_case_two_aux | val terminal_case_two_aux
(#c #eq: _)
(#p: pos)
(#n: _)
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m = 1})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))))
)) | val terminal_case_two_aux
(#c #eq: _)
(#p: pos)
(#n: _)
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m = 1})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))))
)) | let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 205,
"start_col": 0,
"start_line": 190
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_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 |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
generator: FStar.Matrix.matrix_generator c p n ->
m: Prims.pos{m = 1}
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.slice (FStar.Matrix.seq_of_matrix (FStar.Matrix.init generator))
0
(m * n)))
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.init m
(fun i -> FStar.Seq.Permutation.foldm_snoc cm (FStar.Seq.Base.init n (generator i)))
))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix_generator",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__symmetry",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"FStar.IntegerIntervals.under",
"Prims.unit",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Classical.forall_intro",
"Prims.eq2",
"FStar.Seq.Base.index",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Math.Lemmas.small_mod",
"FStar.Math.Lemmas.small_div",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"FStar.Matrix.matrix_seq",
"Prims._assert",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Permutation.foldm_snoc_singleton",
"FStar.Matrix.seq_of_matrix",
"FStar.Matrix.init",
"FStar.Mul.op_Star"
] | [] | false | false | true | false | false | let terminal_case_two_aux
#c
#eq
(#p: pos)
#n
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m = 1})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))))
)) =
| SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert ((SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
`eq.eq`
(SP.foldm_snoc cm (SB.init n (generator 0))));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in
Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line) | false |
Demo.Deps.fst | Demo.Deps.uint32 | val uint32 : Prims.eqtype | let uint32 = U32.t | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 28,
"start_col": 0,
"start_line": 28
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a
let buffer = B.buffer | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Prims.eqtype | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.t"
] | [] | false | false | false | true | false | let uint32 =
| U32.t | false |
|
FStar.Matrix.fst | FStar.Matrix.matrix_fold_equals_double_fold | val matrix_fold_equals_double_fold
(#c #eq: _)
(#p: pos)
(#n: _)
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m <= p})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))))))
(decreases m) | val matrix_fold_equals_double_fold
(#c #eq: _)
(#p: pos)
(#n: _)
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m <= p})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))))))
(decreases m) | let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 92,
"end_line": 285,
"start_col": 0,
"start_line": 242
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 15,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
generator: FStar.Matrix.matrix_generator c p n ->
m: Prims.pos{m <= p}
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.slice (FStar.Matrix.seq_of_matrix (FStar.Matrix.init generator))
0
(m * n)))
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.init m
(fun i ->
FStar.Seq.Permutation.foldm_snoc cm (FStar.Seq.Base.init n (generator i))))))
(decreases m) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix_generator",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"FStar.Matrix.terminal_case_aux",
"Prims.bool",
"FStar.Matrix.terminal_case_two_aux",
"FStar.Seq.Base.seq",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Seq.Permutation.foldm_snoc",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Seq.Base.init",
"Prims.op_Subtraction",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__commutativity",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Matrix.seq_eq_from_member_eq",
"FStar.IntegerIntervals.under",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Seq.Base.index",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Seq.Permutation.foldm_snoc_decomposition",
"FStar.Matrix.liat_equals_init",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc",
"FStar.Classical.forall_intro",
"FStar.Matrix.math_aux_4",
"FStar.Matrix.math_aux_3",
"FStar.Matrix.math_aux_2",
"FStar.Seq.Base.lemma_index_app2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"FStar.Matrix.matrix_fold_equals_double_fold",
"FStar.Seq.Permutation.foldm_snoc_append",
"FStar.Seq.Base.append",
"Prims._assert",
"Prims.l_or",
"Prims.op_GreaterThan",
"Prims.op_GreaterThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Seq.Base.lemma_len_slice",
"FStar.Matrix.matrix_seq",
"FStar.Seq.Base.slice",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.seq_of_matrix",
"FStar.Matrix.init"
] | [
"recursion"
] | false | false | true | false | false | let rec matrix_fold_equals_double_fold
#c
#eq
(#p: pos)
#n
(cm: CE.cm c eq)
(generator: matrix_generator c p n)
(m: pos{m <= p})
: Lemma
(ensures
(SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m * n)))
`eq.eq`
(SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))))))
(decreases m) =
| if p = 1
then terminal_case_aux cm generator m
else
if m = 1
then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m * n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m - 1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m - 1) * n) in
let last_row = SB.slice (matrix_seq generator) ((m - 1) * n) (m * n) in
SB.lemma_len_slice (matrix_seq generator) ((m - 1) * n) (m * n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m - 1);
SB.lemma_eq_elim (SB.init (m - 1) rhs_seq_gen) (SB.init (m - 1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m - 1) j) =
SB.lemma_index_app2 submatrix last_row (j + ((m - 1) * n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
()
in
Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m - 1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m - 1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs
((SP.foldm_snoc cm submatrix) `cm.mult` (SP.foldm_snoc cm last_row))
((SP.foldm_snoc cm last_row) `cm.mult` (SP.foldm_snoc cm submatrix));
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm (SB.init (m - 1) rhs_seq_subgen));
eq.transitivity lhs ((SP.foldm_snoc cm last_row) `cm.mult` (SP.foldm_snoc cm submatrix)) rhs | false |
FStar.Matrix.fst | FStar.Matrix.foldm_snoc_distributivity_right | val foldm_snoc_distributivity_right (#c #eq: _) (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult (SP.foldm_snoc add s) a) `eq.eq` (SP.foldm_snoc add (seq_op_const mul s a))
)
(decreases SB.length s) | val foldm_snoc_distributivity_right (#c #eq: _) (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult (SP.foldm_snoc add s) a) `eq.eq` (SP.foldm_snoc add (seq_op_const mul s a))
)
(decreases SB.length s) | let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 79,
"end_line": 569,
"start_col": 0,
"start_line": 555
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
s: FStar.Seq.Base.seq c ->
a: c
-> FStar.Pervasives.Lemma
(requires
FStar.Matrix.is_fully_distributive mul add /\ FStar.Matrix.is_absorber (CM?.unit add) mul)
(ensures
EQ?.eq eq
(CM?.mult mul (FStar.Seq.Permutation.foldm_snoc add s) a)
(FStar.Seq.Permutation.foldm_snoc add (FStar.Matrix.seq_op_const mul s a)))
(decreases FStar.Seq.Base.length s) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Matrix.seq_op_const",
"FStar.Matrix.foldm_snoc_distributivity_right",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.Mktuple3",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"Prims.bool",
"Prims.l_and",
"FStar.Matrix.is_fully_distributive",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec foldm_snoc_distributivity_right
#c
#eq
(mul: CE.cm c eq)
(add: CE.cm c eq)
(s: SB.seq c)
(a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult (SP.foldm_snoc add s) a) `eq.eq` (SP.foldm_snoc add (seq_op_const mul s a))
)
(decreases SB.length s) =
| if SB.length s > 0
then
let ( + ), ( * ), ( = ) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat * a) rhs_last (sum rhs_liat);
eq.transitivity (sum s * a) (rhs_last + sum liat * a) (rhs_last + sum rhs_liat) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_ijth_as_sum | val matrix_mul_ijth_as_sum (#c:_) (#eq:_) (#m #n #p:pos) (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) | val matrix_mul_ijth_as_sum (#c:_) (#eq:_) (#m #n #p:pos) (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) | let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 597,
"start_col": 0,
"start_line": 590
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mx: FStar.Matrix.matrix c m n ->
my: FStar.Matrix.matrix c n p ->
i: FStar.IntegerIntervals.under m ->
k: FStar.IntegerIntervals.under p
-> FStar.Pervasives.Lemma
(ensures
FStar.Matrix.ijth (FStar.Matrix.matrix_mul add mul mx my) i k ==
FStar.Seq.Permutation.foldm_snoc add
(FStar.Seq.Base.init n
(fun j -> CM?.mult mul (FStar.Matrix.ijth mx i j) (FStar.Matrix.ijth my j k)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"FStar.Matrix.seq_of_products_lemma",
"FStar.Matrix.row",
"FStar.Matrix.col",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"FStar.Matrix.ijth",
"FStar.Matrix.matrix_mul",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Matrix.seq_of_products",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.init",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let matrix_mul_ijth_as_sum
#c
#eq
#m
#n
#p
(add: CE.cm c eq)
(mul: CE.cm c eq)
(mx: matrix c m n)
(my: matrix c n p)
i
k
: Lemma
(ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
| let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r | false |
Demo.Deps.fst | Demo.Deps.uint8 | val uint8 : Prims.eqtype | let uint8 = U8.t | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 16,
"end_line": 29,
"start_col": 0,
"start_line": 29
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a
let buffer = B.buffer | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Prims.eqtype | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt8.t"
] | [] | false | false | false | true | false | let uint8 =
| U8.t | false |
|
Demo.Deps.fst | Demo.Deps.modifies | val modifies : b: LowStar.Buffer.buffer 'a ->
h0: FStar.Monotonic.HyperStack.mem ->
h1: FStar.Monotonic.HyperStack.mem
-> Type0 | let modifies (b:B.buffer 'a) h0 h1 = modifies (loc_buffer b) h0 h1 | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 66,
"end_line": 36,
"start_col": 0,
"start_line": 36
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a
let buffer = B.buffer
let uint32 = U32.t
let uint8 = U8.t
unfold
let length (#a:Type) (b:buffer a) : GTot U32.t =
U32.uint_to_t (B.length b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": 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 |
b: LowStar.Buffer.buffer 'a ->
h0: FStar.Monotonic.HyperStack.mem ->
h1: FStar.Monotonic.HyperStack.mem
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"LowStar.Buffer.buffer",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_buffer",
"LowStar.Buffer.trivial_preorder"
] | [] | false | false | false | true | true | let modifies (b: B.buffer 'a) h0 h1 =
| modifies (loc_buffer b) h0 h1 | false |
|
FStar.Sequence.Base.fst | FStar.Sequence.Base.length | val length : #ty: Type -> seq ty -> nat | val length : #ty: Type -> seq ty -> nat | let length = FLT.length | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 53,
"start_col": 0,
"start_line": 53
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int; | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: FStar.Sequence.Base.seq ty -> Prims.nat | Prims.Tot | [
"total"
] | [] | [
"FStar.List.Tot.Base.length"
] | [] | false | false | false | true | false | let length =
| FLT.length | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.empty | val empty : #ty: Type -> seq ty | val empty : #ty: Type -> seq ty | let empty (#ty: Type) : seq ty = [] | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 59,
"start_col": 0,
"start_line": 59
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T; | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"Prims.Nil",
"FStar.Sequence.Base.seq"
] | [] | false | false | false | true | false | let empty (#ty: Type) : seq ty =
| [] | false |
FStar.Matrix.fst | FStar.Matrix.double_foldm_snoc_of_equal_generators | val double_foldm_snoc_of_equal_generators
(#c #eq: _)
(#m #n: pos)
(cm: CE.cm c eq)
(f g: (under m -> under n -> c))
: Lemma (requires (forall (i: under m) (j: under n). (f i j) `eq.eq` (g i j)))
(ensures
(SP.foldm_snoc cm
(SB.init m
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
`eq.eq`
(SP.foldm_snoc cm
(SB.init m
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))))) | val double_foldm_snoc_of_equal_generators
(#c #eq: _)
(#m #n: pos)
(cm: CE.cm c eq)
(f g: (under m -> under n -> c))
: Lemma (requires (forall (i: under m) (j: under n). (f i j) `eq.eq` (g i j)))
(ensures
(SP.foldm_snoc cm
(SB.init m
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
`eq.eq`
(SP.foldm_snoc cm
(SB.init m
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))))) | let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 112,
"end_line": 660,
"start_col": 0,
"start_line": 649
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
f: (_: FStar.IntegerIntervals.under m -> _: FStar.IntegerIntervals.under n -> c) ->
g: (_: FStar.IntegerIntervals.under m -> _: FStar.IntegerIntervals.under n -> c)
-> FStar.Pervasives.Lemma
(requires
forall (i: FStar.IntegerIntervals.under m) (j: FStar.IntegerIntervals.under n).
EQ?.eq eq (f i j) (g i j))
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.init m
(fun i ->
FStar.Seq.Permutation.foldm_snoc cm (FStar.Seq.Base.init n (fun j -> f i j))))
)
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.init m
(fun i ->
FStar.Seq.Permutation.foldm_snoc cm (FStar.Seq.Base.init n (fun j -> g i j))))
)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.IntegerIntervals.under",
"FStar.Seq.Permutation.foldm_snoc_of_equal_inits",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"Prims.unit",
"FStar.Classical.forall_intro",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims.l_Forall"
] | [] | false | false | true | false | false | let double_foldm_snoc_of_equal_generators
#c
#eq
(#m: pos)
(#n: pos)
(cm: CE.cm c eq)
(f: (under m -> under n -> c))
(g: (under m -> under n -> c))
: Lemma (requires (forall (i: under m) (j: under n). (f i j) `eq.eq` (g i j)))
(ensures
(SP.foldm_snoc cm
(SB.init m
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
`eq.eq`
(SP.foldm_snoc cm
(SB.init m
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))))) =
| let aux i
: Lemma
((SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
`eq.eq`
(SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))) =
SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j)
in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))) | false |
FStar.Matrix.fst | FStar.Matrix.seq_of_products_zeroes_lemma | val seq_of_products_zeroes_lemma
(#c #eq #m: _)
(mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c {SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z))) | val seq_of_products_zeroes_lemma
(#c #eq #m: _)
(mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c {SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z))) | let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 94,
"end_line": 753,
"start_col": 0,
"start_line": 749
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
z: c{FStar.Matrix.is_absorber z mul} ->
s: FStar.Seq.Base.seq c {FStar.Seq.Base.length s == m}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Equiv.eq_of_seq eq
(FStar.Matrix.seq_of_products mul (FStar.Seq.Base.create m z) s)
(FStar.Seq.Base.create m z)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.nat",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Seq.Base.seq",
"Prims.eq2",
"FStar.Seq.Base.length",
"FStar.Seq.Equiv.eq_of_seq_from_element_equality",
"FStar.Matrix.seq_of_products",
"FStar.Seq.Base.create",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Seq.Equiv.eq_of_seq",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let seq_of_products_zeroes_lemma
#c
#eq
#m
(mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c {SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z))) =
| eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z) | false |
Demo.Deps.fst | Demo.Deps.live | val live : h: FStar.Monotonic.HyperStack.mem -> b: Demo.Deps.buffer 'a -> Type0 | let live h (b:buffer 'a) = B.live h b | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 39,
"start_col": 0,
"start_line": 39
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a
let buffer = B.buffer
let uint32 = U32.t
let uint8 = U8.t
unfold
let length (#a:Type) (b:buffer a) : GTot U32.t =
U32.uint_to_t (B.length b)
unfold
let modifies (b:B.buffer 'a) h0 h1 = modifies (loc_buffer b) h0 h1 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": 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 -> b: Demo.Deps.buffer 'a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Demo.Deps.buffer",
"LowStar.Monotonic.Buffer.live",
"LowStar.Buffer.trivial_preorder"
] | [] | false | false | false | true | true | let live h (b: buffer 'a) =
| B.live h b | false |
|
FStar.Sequence.Base.fst | FStar.Sequence.Base.singleton | val singleton : #ty: Type -> ty -> seq ty | val singleton : #ty: Type -> ty -> seq ty | let singleton (#ty: Type) (v: ty) : seq ty =
[v] | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 66,
"start_col": 0,
"start_line": 65
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T; | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | v: ty -> FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"Prims.Cons",
"Prims.Nil",
"FStar.Sequence.Base.seq"
] | [] | false | false | false | true | false | let singleton (#ty: Type) (v: ty) : seq ty =
| [v] | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.build | val build: #ty: Type -> seq ty -> ty -> seq ty | val build: #ty: Type -> seq ty -> ty -> seq ty | let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v] | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 80,
"start_col": 0,
"start_line": 79
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T; | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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.Sequence.Base.seq ty -> v: ty -> FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"FStar.List.Tot.Base.append",
"Prims.Cons",
"Prims.Nil"
] | [] | false | false | false | true | false | let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
| FLT.append s [v] | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.append | val append: #ty: Type -> seq ty -> seq ty -> seq ty | val append: #ty: Type -> seq ty -> seq ty -> seq ty | let append = FLT.append | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 86,
"start_col": 0,
"start_line": 86
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T; | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: FStar.Sequence.Base.seq ty -> _: FStar.Sequence.Base.seq ty -> FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"FStar.List.Tot.Base.append"
] | [] | false | false | false | true | false | let append =
| FLT.append | false |
FStar.Matrix.fst | FStar.Matrix.matrix_right_mul_identity_aux_0 | val matrix_right_mul_identity_aux_0
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k = 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)))
)
`eq.eq`
add.unit) | val matrix_right_mul_identity_aux_0
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k = 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)))
)
`eq.eq`
add.unit) | let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 790,
"start_col": 0,
"start_line": 781
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: Prims.nat{k = 0}
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc add
(FStar.Seq.Base.init k
(fun k ->
CM?.mult mul
(FStar.Matrix.ijth mx i k)
(FStar.Matrix.ijth (FStar.Matrix.matrix_mul_unit add mul m) k j))))
(CM?.unit add)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.nat",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Matrix.ijth",
"FStar.Matrix.matrix_mul_unit",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let matrix_right_mul_identity_aux_0
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: nat{k = 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)))
)
`eq.eq`
add.unit) =
| eq.reflexivity add.unit | false |
Demo.Deps.fst | Demo.Deps.lbuffer | val lbuffer : len: FStar.UInt32.t -> a: Type0 -> Type0 | let lbuffer (len:U32.t) (a:Type) = b:B.buffer a{len <=^ length b} | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 74,
"start_col": 0,
"start_line": 74
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a
let buffer = B.buffer
let uint32 = U32.t
let uint8 = U8.t
unfold
let length (#a:Type) (b:buffer a) : GTot U32.t =
U32.uint_to_t (B.length b)
unfold
let modifies (b:B.buffer 'a) h0 h1 = modifies (loc_buffer b) h0 h1
unfold
let live h (b:buffer 'a) = B.live h b
unfold
let ( .() ) (b:buffer 'a) (i:U32.t)
: ST 'a (requires fun h -> live h b /\ i <^ length b)
(ensures (fun h y h' -> h == h' /\ y == Seq.index (as_seq h b) (U32.v i)))
= B.index b i
unfold
let ( .()<- ) (b:buffer 'a) (i:U32.t) (v:'a)
: ST unit
(requires (fun h ->
live h b /\
i <^ length b))
(ensures (fun h _ h' ->
modifies b h h' /\
live h' b /\
as_seq h' b == Seq.upd (as_seq h b) (U32.v i) v))
= B.upd b i v
unfold
let suffix (#a:Type)
(b:buffer a)
(from:U32.t)
(len:U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h ->
U32.v from + U32.v len <= U32.v (length b) /\
live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from)))
= B.sub b from (len -^ from)
unfold
let disjoint (b0 b1:B.buffer 'a) = B.disjoint b0 b1 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": 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: FStar.UInt32.t -> a: Type0 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.t",
"LowStar.Buffer.buffer",
"Prims.b2t",
"FStar.UInt32.op_Less_Equals_Hat",
"Demo.Deps.length"
] | [] | false | false | false | true | true | let lbuffer (len: U32.t) (a: Type) =
| b: B.buffer a {len <=^ length b} | false |
|
FStar.Sequence.Base.fst | FStar.Sequence.Base.take | val take: #ty: Type -> s: seq ty -> howMany: nat{howMany <= length s} -> seq ty | val take: #ty: Type -> s: seq ty -> howMany: nat{howMany <= length s} -> seq ty | let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 8,
"end_line": 109,
"start_col": 0,
"start_line": 107
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T; | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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.Sequence.Base.seq ty -> howMany: Prims.nat{howMany <= FStar.Sequence.Base.length s}
-> FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"FStar.List.Tot.Base.splitAt"
] | [] | false | false | false | false | false | let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
| let result, _ = FLT.splitAt howMany s in
result | false |
Demo.Deps.fst | Demo.Deps.disjoint | val disjoint : b0: LowStar.Buffer.buffer 'a -> b1: LowStar.Buffer.buffer 'a -> Type0 | let disjoint (b0 b1:B.buffer 'a) = B.disjoint b0 b1 | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 72,
"start_col": 0,
"start_line": 72
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a
let buffer = B.buffer
let uint32 = U32.t
let uint8 = U8.t
unfold
let length (#a:Type) (b:buffer a) : GTot U32.t =
U32.uint_to_t (B.length b)
unfold
let modifies (b:B.buffer 'a) h0 h1 = modifies (loc_buffer b) h0 h1
unfold
let live h (b:buffer 'a) = B.live h b
unfold
let ( .() ) (b:buffer 'a) (i:U32.t)
: ST 'a (requires fun h -> live h b /\ i <^ length b)
(ensures (fun h y h' -> h == h' /\ y == Seq.index (as_seq h b) (U32.v i)))
= B.index b i
unfold
let ( .()<- ) (b:buffer 'a) (i:U32.t) (v:'a)
: ST unit
(requires (fun h ->
live h b /\
i <^ length b))
(ensures (fun h _ h' ->
modifies b h h' /\
live h' b /\
as_seq h' b == Seq.upd (as_seq h b) (U32.v i) v))
= B.upd b i v
unfold
let suffix (#a:Type)
(b:buffer a)
(from:U32.t)
(len:U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h ->
U32.v from + U32.v len <= U32.v (length b) /\
live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from)))
= B.sub b from (len -^ from) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": 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 | b0: LowStar.Buffer.buffer 'a -> b1: LowStar.Buffer.buffer 'a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"LowStar.Buffer.buffer",
"LowStar.Monotonic.Buffer.disjoint",
"LowStar.Buffer.trivial_preorder"
] | [] | false | false | false | true | true | let disjoint (b0 b1: B.buffer 'a) =
| B.disjoint b0 b1 | false |
|
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop | val drop: #ty: Type -> s: seq ty -> howMany: nat{howMany <= length s} -> seq ty | val drop: #ty: Type -> s: seq ty -> howMany: nat{howMany <= length s} -> seq ty | let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 8,
"end_line": 117,
"start_col": 0,
"start_line": 115
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T; | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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.Sequence.Base.seq ty -> howMany: Prims.nat{howMany <= FStar.Sequence.Base.length s}
-> FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"FStar.List.Tot.Base.splitAt"
] | [] | false | false | false | false | false | let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
| let _, result = FLT.splitAt howMany s in
result | false |
FStar.Matrix.fst | FStar.Matrix.matrix_left_mul_identity_aux_0 | val matrix_left_mul_identity_aux_0
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k = 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_mul_unit add mul m) i k) `mul.mult` (ijth mx k j)))
)
`eq.eq`
add.unit) | val matrix_left_mul_identity_aux_0
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k = 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_mul_unit add mul m) i k) `mul.mult` (ijth mx k j)))
)
`eq.eq`
add.unit) | let matrix_left_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) = eq.reflexivity add.unit | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 917,
"start_col": 0,
"start_line": 910
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit
let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_right_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1){k>j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j)
(decreases k) =
if (k-1) > j+1 then matrix_right_mul_identity_aux_3 add mul mx i j (k-1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k-1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let subgen (i: under (k)) = gen i in
let full = SB.init k gen in
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_right_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq`
(if k>j then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else if k <= j then matrix_right_mul_identity_aux_1 add mul mx i j k
else if k = j+1 then matrix_right_mul_identity_aux_2 add mul mx i j k
else matrix_right_mul_identity_aux_3 add mul mx i j k | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: Prims.nat{k = 0}
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc add
(FStar.Seq.Base.init k
(fun k ->
CM?.mult mul
(FStar.Matrix.ijth (FStar.Matrix.matrix_mul_unit add mul m) i k)
(FStar.Matrix.ijth mx k j))))
(CM?.unit add)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.nat",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Matrix.ijth",
"FStar.Matrix.matrix_mul_unit",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let matrix_left_mul_identity_aux_0
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: nat{k = 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_mul_unit add mul m) i k) `mul.mult` (ijth mx k j)))
)
`eq.eq`
add.unit) =
| eq.reflexivity add.unit | false |
FStar.Matrix.fst | FStar.Matrix.foldm_snoc_zero_lemma | val foldm_snoc_zero_lemma (#c #eq: _) (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). (SB.index zeroes i) `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) | val foldm_snoc_zero_lemma (#c #eq: _) (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). (SB.index zeroes i) `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) | let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 770,
"start_col": 0,
"start_line": 755
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | add: FStar.Algebra.CommMonoid.Equiv.cm c eq -> zeroes: FStar.Seq.Base.seq c
-> FStar.Pervasives.Lemma
(requires
forall (i: FStar.IntegerIntervals.under (FStar.Seq.Base.length zeroes)).
EQ?.eq eq (FStar.Seq.Base.index zeroes i) (CM?.unit add))
(ensures EQ?.eq eq (FStar.Seq.Permutation.foldm_snoc add zeroes) (CM?.unit add))
(decreases FStar.Seq.Base.length zeroes) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Seq.Base.seq",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"FStar.Seq.Permutation.foldm_snoc",
"Prims.bool",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Seq.Permutation.foldm_snoc_decomposition",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__identity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Matrix.foldm_snoc_zero_lemma",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc",
"Prims.l_Forall",
"FStar.IntegerIntervals.under",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Base.index",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). (SB.index zeroes i) `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
| if (SB.length zeroes < 1)
then
(assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit)
else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes) (add.mult add.unit add.unit) add.unit | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.contains | val contains: #ty: Type -> seq ty -> ty -> Type0 | val contains: #ty: Type -> seq ty -> ty -> Type0 | let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 101,
"start_col": 0,
"start_line": 100
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool; | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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.Sequence.Base.seq ty -> v: ty -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"FStar.List.Tot.Base.memP"
] | [] | false | false | false | true | true | let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
| FLT.memP v s | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_unit_row_lemma | val matrix_mul_unit_row_lemma (#c #eq m: _) (add mul: CE.cm c eq) (i: under m)
: Lemma
((row (matrix_mul_unit add mul m) i ==
(SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit))) /\
(row (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit))
`SB.append`
(SB.create (m - i - 1) add.unit))) | val matrix_mul_unit_row_lemma (#c #eq m: _) (add mul: CE.cm c eq) (i: under m)
: Lemma
((row (matrix_mul_unit add mul m) i ==
(SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit))) /\
(row (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit))
`SB.append`
(SB.create (m - i - 1) add.unit))) | let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 733,
"start_col": 0,
"start_line": 721
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
m: Prims.nat ->
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
i: FStar.IntegerIntervals.under m
-> FStar.Pervasives.Lemma
(ensures
FStar.Matrix.row (FStar.Matrix.matrix_mul_unit add mul m) i ==
FStar.Seq.Base.append (FStar.Seq.Base.create i (CM?.unit add))
(FStar.Seq.Base.append (FStar.Seq.Base.create 1 (CM?.unit mul))
(FStar.Seq.Base.create (m - i - 1) (CM?.unit add))) /\
FStar.Matrix.row (FStar.Matrix.matrix_mul_unit add mul m) i ==
FStar.Seq.Base.append (FStar.Seq.Base.append (FStar.Seq.Base.create i (CM?.unit add))
(FStar.Seq.Base.create 1 (CM?.unit mul)))
(FStar.Seq.Base.create (m - i - 1) (CM?.unit add))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.nat",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.IntegerIntervals.under",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.append",
"FStar.Seq.Base.create",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"Prims.op_Subtraction",
"FStar.Matrix.row",
"FStar.Matrix.matrix_mul_unit",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let matrix_mul_unit_row_lemma #c #eq m (add: CE.cm c eq) (mul: CE.cm c eq) (i: under m)
: Lemma
((row (matrix_mul_unit add mul m) i ==
(SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit))) /\
(row (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit))
`SB.append`
(SB.create (m - i - 1) add.unit))) =
| SB.lemma_eq_elim (((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit))
`SB.append`
(SB.create (m - i - 1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit)))
(row (matrix_mul_unit add mul m) i) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_right_identity_aux | val matrix_right_identity_aux
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1))
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)
)))
`eq.eq`
(if k > j then ijth mx i j else add.unit)) (decreases k) | val matrix_right_identity_aux
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1))
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)
)))
`eq.eq`
(if k > j then ijth mx i j else add.unit)) (decreases k) | let matrix_right_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq`
(if k>j then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else if k <= j then matrix_right_mul_identity_aux_1 add mul mx i j k
else if k = j+1 then matrix_right_mul_identity_aux_2 add mul mx i j k
else matrix_right_mul_identity_aux_3 add mul mx i j k | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 55,
"end_line": 908,
"start_col": 0,
"start_line": 895
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit
let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_right_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1){k>j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j)
(decreases k) =
if (k-1) > j+1 then matrix_right_mul_identity_aux_3 add mul mx i j (k-1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k-1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let subgen (i: under (k)) = gen i in
let full = SB.init k gen in
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: FStar.IntegerIntervals.under (m + 1)
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc add
(FStar.Seq.Base.init k
(fun k ->
CM?.mult mul
(FStar.Matrix.ijth mx i k)
(FStar.Matrix.ijth (FStar.Matrix.matrix_mul_unit add mul m) k j))))
(match k > j with
| true -> FStar.Matrix.ijth mx i j
| _ -> CM?.unit add)) (decreases k) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.op_Addition",
"Prims.op_Equality",
"Prims.int",
"FStar.Matrix.matrix_right_mul_identity_aux_0",
"Prims.bool",
"Prims.op_LessThanOrEqual",
"FStar.Matrix.matrix_right_mul_identity_aux_1",
"FStar.Matrix.matrix_right_mul_identity_aux_2",
"FStar.Matrix.matrix_right_mul_identity_aux_3",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Matrix.ijth",
"FStar.Matrix.matrix_mul_unit",
"Prims.op_GreaterThan",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let matrix_right_identity_aux
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: under (m + 1))
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)
)))
`eq.eq`
(if k > j then ijth mx i j else add.unit)) (decreases k) =
| if k = 0
then matrix_right_mul_identity_aux_0 add mul mx i j k
else
if k <= j
then matrix_right_mul_identity_aux_1 add mul mx i j k
else
if k = j + 1
then matrix_right_mul_identity_aux_2 add mul mx i j k
else matrix_right_mul_identity_aux_3 add mul mx i j k | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.rank | val rank: #ty: Type -> ty -> ty | val rank: #ty: Type -> ty -> ty | let rank (#ty: Type) (v: ty) = v | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 143,
"start_col": 0,
"start_line": 143
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int; | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | v: ty -> ty | Prims.Tot | [
"total"
] | [] | [] | [] | false | false | false | true | false | let rank (#ty: Type) (v: ty) =
| v | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_unit_col_lemma | val matrix_mul_unit_col_lemma (#c #eq m: _) (add mul: CE.cm c eq) (i: under m)
: Lemma
((col (matrix_mul_unit add mul m) i ==
(SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit))
`SB.append`
(SB.create (m - i - 1) add.unit))) | val matrix_mul_unit_col_lemma (#c #eq m: _) (add mul: CE.cm c eq) (i: under m)
: Lemma
((col (matrix_mul_unit add mul m) i ==
(SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit))
`SB.append`
(SB.create (m - i - 1) add.unit))) | let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 747,
"start_col": 0,
"start_line": 735
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
m: Prims.nat ->
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
i: FStar.IntegerIntervals.under m
-> FStar.Pervasives.Lemma
(ensures
FStar.Matrix.col (FStar.Matrix.matrix_mul_unit add mul m) i ==
FStar.Seq.Base.append (FStar.Seq.Base.create i (CM?.unit add))
(FStar.Seq.Base.append (FStar.Seq.Base.create 1 (CM?.unit mul))
(FStar.Seq.Base.create (m - i - 1) (CM?.unit add))) /\
FStar.Matrix.col (FStar.Matrix.matrix_mul_unit add mul m) i ==
FStar.Seq.Base.append (FStar.Seq.Base.append (FStar.Seq.Base.create i (CM?.unit add))
(FStar.Seq.Base.create 1 (CM?.unit mul)))
(FStar.Seq.Base.create (m - i - 1) (CM?.unit add))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.nat",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.IntegerIntervals.under",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Seq.Base.append",
"FStar.Seq.Base.create",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"Prims.op_Subtraction",
"FStar.Matrix.col",
"FStar.Matrix.matrix_mul_unit",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let matrix_mul_unit_col_lemma #c #eq m (add: CE.cm c eq) (mul: CE.cm c eq) (i: under m)
: Lemma
((col (matrix_mul_unit add mul m) i ==
(SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit))
`SB.append`
(SB.create (m - i - 1) add.unit))) =
| SB.lemma_eq_elim (((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit))
`SB.append`
(SB.create (m - i - 1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit)
`SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m - i - 1) add.unit)))
(col (matrix_mul_unit add mul m) i) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_left_identity | val matrix_mul_left_identity (#c:_) (#eq:_) (#m: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul (matrix_mul_unit add mul m) mx `(matrix_equiv eq m m).eq` mx) | val matrix_mul_left_identity (#c:_) (#eq:_) (#m: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul (matrix_mul_unit add mul m) mx `(matrix_equiv eq m m).eq` mx) | let matrix_mul_left_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul (matrix_mul_unit add mul m) mx `matrix_eq_fun eq` mx) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul unit mx in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : squash (ijth mxu i j $=$ ijth mx i j) =
let gen (k: under m) = ijth unit i k * ijth mx k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul unit mx i j gen;
let seq = SB.init m gen in
matrix_left_identity_aux add mul mx i j m
in
matrix_equiv_from_proof eq mxu mx aux | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 1060,
"start_col": 0,
"start_line": 1046
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit
let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_right_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1){k>j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j)
(decreases k) =
if (k-1) > j+1 then matrix_right_mul_identity_aux_3 add mul mx i j (k-1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k-1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let subgen (i: under (k)) = gen i in
let full = SB.init k gen in
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_right_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq`
(if k>j then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else if k <= j then matrix_right_mul_identity_aux_1 add mul mx i j k
else if k = j+1 then matrix_right_mul_identity_aux_2 add mul mx i j k
else matrix_right_mul_identity_aux_3 add mul mx i j k
let matrix_left_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) = eq.reflexivity add.unit
let rec matrix_left_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=i /\ k>0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
if k=1 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
SP.foldm_snoc_decomposition add full;
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
#push-options "--z3rlimit 20"
let matrix_left_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
assert (k-1 <= i /\ k-1 >= 0);
if (k-1)=0 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_left_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under(m+1){k>i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
if (k-1 = i+1) then matrix_left_mul_identity_aux_2 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_3 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_left_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` (if k>i then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_left_mul_identity_aux_0 add mul mx i j k
else if k <= i then matrix_left_mul_identity_aux_1 add mul mx i j k
else if k = i+1 then matrix_left_mul_identity_aux_2 add mul mx i j k
else matrix_left_mul_identity_aux_3 add mul mx i j k
let matrix_mul_right_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `matrix_eq_fun eq` mx) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : Lemma (ijth mxu i j $=$ ijth mx i j) =
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx unit i j gen;
let seq = SB.init m gen in
matrix_right_identity_aux add mul mx i j m
in Classical.forall_intro_2 aux;
matrix_equiv_from_element_eq eq mxu mx | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq (FStar.Matrix.matrix_equiv eq m m)
(FStar.Matrix.matrix_mul add mul (FStar.Matrix.matrix_mul_unit add mul m) mx)
mx) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_proof",
"FStar.IntegerIntervals.under",
"Prims.squash",
"FStar.Matrix.ijth",
"FStar.Matrix.matrix_left_identity_aux",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.init",
"Prims.unit",
"FStar.Matrix.matrix_mul_ijth_eq_sum_of_seq_for_init",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Matrix.matrix_mul",
"FStar.Matrix.matrix_mul_unit",
"Prims.l_True",
"FStar.Matrix.matrix_eq_fun",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let matrix_mul_left_identity
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_eq_fun eq (matrix_mul add mul (matrix_mul_unit add mul m) mx) mx) =
| let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul unit mx in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : squash (ijth mxu i j $=$ ijth mx i j) =
let gen (k: under m) = ijth unit i k * ijth mx k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul unit mx i j gen;
let seq = SB.init m gen in
matrix_left_identity_aux add mul mx i j m
in
matrix_equiv_from_proof eq mxu mx aux | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_identity | val matrix_mul_identity (#c:_) (#eq:_) (#m: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `(matrix_equiv eq m m).eq` mx /\
matrix_mul add mul (matrix_mul_unit add mul m) mx `(matrix_equiv eq m m).eq` mx) | val matrix_mul_identity (#c:_) (#eq:_) (#m: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `(matrix_equiv eq m m).eq` mx /\
matrix_mul add mul (matrix_mul_unit add mul m) mx `(matrix_equiv eq m m).eq` mx) | let matrix_mul_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `matrix_eq_fun eq` mx /\
matrix_mul add mul (matrix_mul_unit add mul m) mx `matrix_eq_fun eq` mx) =
matrix_mul_left_identity add mul mx;
matrix_mul_right_identity add mul mx | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 1068,
"start_col": 0,
"start_line": 1062
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit
let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_right_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1){k>j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j)
(decreases k) =
if (k-1) > j+1 then matrix_right_mul_identity_aux_3 add mul mx i j (k-1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k-1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let subgen (i: under (k)) = gen i in
let full = SB.init k gen in
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_right_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq`
(if k>j then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else if k <= j then matrix_right_mul_identity_aux_1 add mul mx i j k
else if k = j+1 then matrix_right_mul_identity_aux_2 add mul mx i j k
else matrix_right_mul_identity_aux_3 add mul mx i j k
let matrix_left_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) = eq.reflexivity add.unit
let rec matrix_left_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=i /\ k>0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
if k=1 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
SP.foldm_snoc_decomposition add full;
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
#push-options "--z3rlimit 20"
let matrix_left_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
assert (k-1 <= i /\ k-1 >= 0);
if (k-1)=0 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_left_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under(m+1){k>i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
if (k-1 = i+1) then matrix_left_mul_identity_aux_2 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_3 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_left_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` (if k>i then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_left_mul_identity_aux_0 add mul mx i j k
else if k <= i then matrix_left_mul_identity_aux_1 add mul mx i j k
else if k = i+1 then matrix_left_mul_identity_aux_2 add mul mx i j k
else matrix_left_mul_identity_aux_3 add mul mx i j k
let matrix_mul_right_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `matrix_eq_fun eq` mx) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : Lemma (ijth mxu i j $=$ ijth mx i j) =
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx unit i j gen;
let seq = SB.init m gen in
matrix_right_identity_aux add mul mx i j m
in Classical.forall_intro_2 aux;
matrix_equiv_from_element_eq eq mxu mx
let matrix_mul_left_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul (matrix_mul_unit add mul m) mx `matrix_eq_fun eq` mx) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul unit mx in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : squash (ijth mxu i j $=$ ijth mx i j) =
let gen (k: under m) = ijth unit i k * ijth mx k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul unit mx i j gen;
let seq = SB.init m gen in
matrix_left_identity_aux add mul mx i j m
in
matrix_equiv_from_proof eq mxu mx aux | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq (FStar.Matrix.matrix_equiv eq m m)
(FStar.Matrix.matrix_mul add mul mx (FStar.Matrix.matrix_mul_unit add mul m))
mx /\
EQ?.eq (FStar.Matrix.matrix_equiv eq m m)
(FStar.Matrix.matrix_mul add mul (FStar.Matrix.matrix_mul_unit add mul m) mx)
mx) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_mul_right_identity",
"Prims.unit",
"FStar.Matrix.matrix_mul_left_identity",
"Prims.l_True",
"Prims.squash",
"Prims.l_and",
"FStar.Matrix.matrix_eq_fun",
"FStar.Matrix.matrix_mul",
"FStar.Matrix.matrix_mul_unit",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let matrix_mul_identity
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma
(matrix_eq_fun eq (matrix_mul add mul mx (matrix_mul_unit add mul m)) mx /\
matrix_eq_fun eq (matrix_mul add mul (matrix_mul_unit add mul m) mx) mx) =
| matrix_mul_left_identity add mul mx;
matrix_mul_right_identity add mul mx | false |
Steel.ST.HigherArray.fst | Steel.ST.HigherArray.ghost_join | val ghost_join
(#opened: _)
(#elt: Type)
(#x1 #x2: Seq.seq elt)
(#p: P.perm)
(a1 a2: array elt)
(h: squash (adjacent a1 a2))
: STGhostT unit opened
(pts_to a1 p x1 `star` pts_to a2 p x2)
(fun res -> pts_to (merge a1 a2) p (x1 `Seq.append` x2)) | val ghost_join
(#opened: _)
(#elt: Type)
(#x1 #x2: Seq.seq elt)
(#p: P.perm)
(a1 a2: array elt)
(h: squash (adjacent a1 a2))
: STGhostT unit opened
(pts_to a1 p x1 `star` pts_to a2 p x2)
(fun res -> pts_to (merge a1 a2) p (x1 `Seq.append` x2)) | let ghost_join
#_ #_ #x1 #x2 #p a1 a2 h
= elim_pts_to a1 p x1;
elim_pts_to a2 p x2;
mk_carrier_merge (US.v (ptr_of a1).base_len) ((ptr_of a1).offset) x1 x2 (p);
change_r_pts_to
(ptr_of a2).base _
(ptr_of a1).base (mk_carrier (US.v (ptr_of a1).base_len) ((ptr_of a1).offset + Seq.length x1) x2 p);
R.gather (ptr_of a1).base
(mk_carrier (US.v (ptr_of a1).base_len) ((ptr_of a1).offset) x1 (p))
(mk_carrier (US.v (ptr_of a1).base_len) ((ptr_of a1).offset + Seq.length x1) x2 (p));
change_r_pts_to
(ptr_of a1).base _
(ptr_of (merge a1 a2)).base (mk_carrier (US.v (ptr_of (merge a1 a2)).base_len) ((ptr_of (merge a1 a2)).offset) (x1 `Seq.append` x2) (p));
intro_pts_to (merge a1 a2) p (Seq.append x1 x2) | {
"file_name": "lib/steel/Steel.ST.HigherArray.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 49,
"end_line": 521,
"start_col": 0,
"start_line": 507
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.ST.HigherArray
module P = Steel.PCMFrac
module R = Steel.ST.PCMReference
module M = FStar.Map
module PM = Steel.PCMMap
[@@noextract_to "krml"]
let index_t (len: Ghost.erased nat) : Tot Type0 =
(i: nat { i < len })
[@@noextract_to "krml"]
let carrier (elt: Type u#a) (len: Ghost.erased nat) : Tot Type =
PM.map (index_t len) (P.fractional elt)
[@@noextract_to "krml"]
let pcm (elt: Type u#a) (len: Ghost.erased nat) : Tot (P.pcm (carrier elt len)) =
PM.pointwise (index_t len) (P.pcm_frac #elt)
[@@noextract_to "krml"]
let one (#elt: Type) (#len: Ghost.erased nat) = (pcm elt len).P.p.P.one
let composable (#elt: Type) (#len: Ghost.erased nat) = (pcm elt len).P.p.P.composable
[@@noextract_to "krml"]
let compose (#elt: Type) (#len: Ghost.erased nat) = (pcm elt len).P.p.P.op
[@@noextract_to "krml"]
let mk_carrier
(#elt: Type)
(len: nat)
(offset: nat)
(s: Seq.seq elt)
(p: P.perm)
: Tot (carrier elt len)
= let f (i: nat) : Tot (P.fractional elt) =
if offset + Seq.length s > len || i < offset || i >= offset + Seq.length s
then None
else Some (Seq.index s (i - offset), p)
in
M.map_literal f
let mk_carrier_inj
(#elt: Type)
(len: nat)
(offset: nat)
(s1 s2: Seq.seq elt)
(p1 p2: P.perm)
: Lemma
(requires (
mk_carrier len offset s1 p1 == mk_carrier len offset s2 p2 /\
offset + Seq.length s1 <= len /\
offset + Seq.length s2 <= len
))
(ensures (
s1 `Seq.equal` s2 /\
(Seq.length s1 > 0 ==> p1 == p2)
))
= assert (forall (i: nat) . i < Seq.length s1 ==>
(M.sel (mk_carrier len offset s1 p1) (offset + i) == Some (Seq.index s1 i, p1)));
assert (forall (i: nat) . i < Seq.length s2 ==>
M.sel (mk_carrier len offset s2 p2) (offset + i) == Some (Seq.index s2 i, p2))
[@@erasable]
let base_t (elt: Type u#a) : Tot Type0 = Ghost.erased (base_len: US.t & ref _ (pcm elt (US.v base_len)))
let base_len (#elt: Type) (b: base_t elt) : GTot nat = US.v (dfst b)
[@@noextract_to "krml"]
noeq
type ptr (elt: Type u#a) : Type0 = {
base_len: Ghost.erased US.t;
// U32.t to prove that A.read, A.write offset computation does not overflow. TODO: replace U32.t with size_t
base: (r: ref _ (pcm elt (US.v base_len)) { core_ref_is_null r ==> US.v base_len == 0 });
offset: (offset: nat { offset <= US.v base_len });
}
let null_ptr a = { base_len = 0sz; base = null #_ #(pcm a 0) ; offset = 0 }
let is_null_ptr p = is_null p.base
let base (#elt: Type) (p: ptr elt) : Tot (base_t elt) = (| Ghost.reveal p.base_len, p.base |)
let offset (#elt: Type) (p: ptr elt) : Ghost nat (requires True) (ensures (fun offset -> offset <= base_len (base p))) = p.offset
let ptr_base_offset_inj (#elt: Type) (p1 p2: ptr elt) : Lemma
(requires (
base p1 == base p2 /\
offset p1 == offset p2
))
(ensures (
p1 == p2
))
= ()
let base_len_null_ptr _ = ()
let length_fits #elt a = ()
let valid_perm
(len: nat)
(offset: nat)
(slice_len: nat)
(p: P.perm) : Tot prop =
let open FStar.Real in
((offset + slice_len <= len /\ slice_len > 0) ==> (p.P.v <=. one))
[@__reduce__]
let pts_to0 (#elt: Type u#1) (a: array elt) (p: P.perm) (s: Seq.seq elt) : Tot vprop =
R.pts_to (ptr_of a).base (mk_carrier (US.v (ptr_of a).base_len) (ptr_of a).offset s p) `star`
pure (
valid_perm (US.v (ptr_of a).base_len) (ptr_of a).offset (Seq.length s) p /\
Seq.length s == length a
)
let pts_to (#elt: Type u#1) (a: array elt) ([@@@ smt_fallback ] p: P.perm) ([@@@ smt_fallback ] s: Seq.seq elt) : Tot vprop =
pts_to0 a p s
// this lemma is necessary because Steel.PCMReference is marked unfold
let change_r_pts_to
(#opened: _)
(#carrier: Type u#1)
(#pcm: P.pcm carrier)
(p: ref carrier pcm)
(v: carrier)
(#carrier': Type u#1)
(#pcm': P.pcm carrier')
(p': ref carrier' pcm')
(v': carrier')
: STGhost unit opened
(R.pts_to p v)
(fun _ -> R.pts_to p' v')
(// keep on distinct lines for error messages
carrier == carrier' /\
pcm == pcm' /\
p == p' /\
v == v')
(fun _ -> True)
= rewrite
(R.pts_to p v)
(R.pts_to p' v')
let intro_pts_to (#opened: _) (#elt: Type u#1) (a: array elt) (#v: _) (p: P.perm) (s: Seq.seq elt) : STGhost unit opened
(R.pts_to (ptr_of a).base v)
(fun _ -> pts_to a p s)
(
v == mk_carrier (US.v (ptr_of a).base_len) (ptr_of a).offset s p /\
valid_perm (US.v (ptr_of a).base_len) (ptr_of a).offset (Seq.length s) p /\
Seq.length s == length a
)
(fun _ -> True)
= change_r_pts_to (ptr_of a).base v (ptr_of a).base (mk_carrier (US.v (ptr_of a).base_len) (ptr_of a).offset s p);
intro_pure _;
rewrite
(pts_to0 a p s)
(pts_to a p s)
let elim_pts_to (#opened: _) (#elt: Type u#1) (a: array elt) (p: P.perm) (s: Seq.seq elt) : STGhost unit opened
(pts_to a p s)
(fun _ -> R.pts_to (ptr_of a).base (mk_carrier (US.v (ptr_of a).base_len) (ptr_of a).offset s p))
(True)
(fun _ ->
valid_perm (US.v (ptr_of a).base_len) (ptr_of a).offset (Seq.length s) p /\
Seq.length s == length a
)
= rewrite
(pts_to a p s)
(pts_to0 a p s);
elim_pure _
let pts_to_length
a s
=
elim_pts_to a _ s;
intro_pts_to a _ s
let pts_to_not_null
a s
= elim_pts_to a _ s;
R.pts_to_not_null _ _;
intro_pts_to a _ s
let mk_carrier_joinable
(#elt: Type)
(len: nat)
(offset: nat)
(s1: Seq.seq elt)
(p1: P.perm)
(s2: Seq.seq elt)
(p2: P.perm)
: Lemma
(requires (
offset + Seq.length s1 <= len /\
Seq.length s1 == Seq.length s2 /\
P.joinable (pcm elt len) (mk_carrier len offset s1 p1) (mk_carrier len offset s2 p2)
))
(ensures (
s1 `Seq.equal` s2
))
=
let lem
(i: nat { 0 <= i /\ i < Seq.length s1 })
: Lemma
(Seq.index s1 i == Seq.index s2 i)
[SMTPat (Seq.index s1 i); SMTPat (Seq.index s2 i)]
= assert (
forall z . (
P.compatible (pcm elt len) (mk_carrier len offset s1 p1) z /\
P.compatible (pcm elt len) (mk_carrier len offset s2 p2) z
) ==>
begin match M.sel z (offset + i) with
| None -> False
| Some (v, _) -> v == Seq.index s1 i /\ v == Seq.index s2 i
end
)
in
()
let pure_star_interp' (p:slprop u#a) (q:prop) (m:mem)
: Lemma (interp (p `Steel.Memory.star` Steel.Memory.pure q) m <==>
interp p m /\ q)
= pure_star_interp p q m;
emp_unit p
let pts_to_inj
a p1 s1 p2 s2 m
=
Classical.forall_intro reveal_pure;
pure_star_interp'
(hp_of (R.pts_to (ptr_of a).base (mk_carrier (US.v (ptr_of a).base_len) (ptr_of a).offset s1 p1)))
(
valid_perm (US.v (ptr_of a).base_len) (ptr_of a).offset (Seq.length s1) p1 /\
Seq.length s1 == length a
)
m;
pure_star_interp'
(hp_of (R.pts_to (ptr_of a).base (mk_carrier (US.v (ptr_of a).base_len) (ptr_of a).offset s2 p2)))
(
valid_perm (US.v (ptr_of a).base_len) (ptr_of a).offset (Seq.length s2) p2 /\
Seq.length s2 == length a
)
m;
pts_to_join
(ptr_of a).base
(mk_carrier (US.v (ptr_of a).base_len) (ptr_of a).offset s1 p1)
(mk_carrier (US.v (ptr_of a).base_len) (ptr_of a).offset s2 p2)
m;
mk_carrier_joinable (US.v (ptr_of a).base_len) (ptr_of a).offset s1 p1 s2 p2
[@@noextract_to "krml"]
let malloc0
(#elt: Type)
(x: elt)
(n: US.t)
: ST (array elt)
emp
(fun a -> pts_to a P.full_perm (Seq.create (US.v n) x))
(True)
(fun a ->
length a == US.v n /\
base_len (base (ptr_of a)) == US.v n
)
=
let c : carrier elt (US.v n) = mk_carrier (US.v n) 0 (Seq.create (US.v n) x) P.full_perm in
let base : ref (carrier elt (US.v n)) (pcm elt (US.v n)) = R.alloc c in
R.pts_to_not_null base _;
let p = {
base_len = n;
base = base;
offset = 0;
}
in
let a = (| p, Ghost.hide (US.v n) |) in
change_r_pts_to
base c
(ptr_of a).base c;
intro_pts_to a P.full_perm (Seq.create (US.v n) x);
return a
let malloc_ptr
x n
=
let a = malloc0 x n in
let (| p, _ |) = a in
rewrite
(pts_to _ _ _)
(pts_to (| p, Ghost.hide (US.v n) |) _ _);
return p
[@@noextract_to "krml"]
let free0
(#elt: Type)
(#s: Ghost.erased (Seq.seq elt))
(a: array elt)
: ST unit
(pts_to a P.full_perm s)
(fun _ -> emp)
(
length a == base_len (base (ptr_of a))
)
(fun _ -> True)
= drop (pts_to a _ _)
let free_ptr a =
free0 _
let valid_sum_perm
(len: nat)
(offset: nat)
(slice_len: nat)
(p1 p2: P.perm)
: Tot prop
= let open FStar.Real in
valid_perm len offset slice_len (P.sum_perm p1 p2)
let mk_carrier_share
(#elt: Type)
(len: nat)
(offset: nat)
(s: Seq.seq elt)
(p1 p2: P.perm)
: Lemma
(requires (valid_sum_perm len offset (Seq.length s) p1 p2))
(ensures (
let c1 = mk_carrier len offset s p1 in
let c2 = mk_carrier len offset s p2 in
composable c1 c2 /\
mk_carrier len offset s (p1 `P.sum_perm` p2) `M.equal` (c1 `compose` c2)
))
= ()
let share
#_ #_ #x a p p1 p2
= elim_pts_to a p x;
mk_carrier_share (US.v (ptr_of a).base_len) (ptr_of a).offset x p1 p2;
R.split (ptr_of a).base _
(mk_carrier (US.v (ptr_of a).base_len) (ptr_of a).offset x p1)
(mk_carrier (US.v (ptr_of a).base_len) (ptr_of a).offset x p2);
intro_pts_to a p1 x;
intro_pts_to a p2 x
let mk_carrier_gather
(#elt: Type)
(len: nat)
(offset: nat)
(s1 s2: Seq.seq elt)
(p1 p2: P.perm)
: Lemma
(requires (
let c1 = mk_carrier len offset s1 p1 in
let c2 = mk_carrier len offset s2 p2 in
composable c1 c2 /\
Seq.length s1 == Seq.length s2 /\
offset + Seq.length s1 <= len
))
(ensures (
let c1 = mk_carrier len offset s1 p1 in
let c2 = mk_carrier len offset s2 p2 in
composable c1 c2 /\
mk_carrier len offset s1 (p1 `P.sum_perm` p2) == (c1 `compose` c2) /\
mk_carrier len offset s2 (p1 `P.sum_perm` p2) == (c1 `compose` c2) /\
s1 == s2
))
=
let c1 = mk_carrier len offset s1 p1 in
let c2 = mk_carrier len offset s2 p2 in
assert (composable c1 c2);
assert (mk_carrier len offset s1 (p1 `P.sum_perm` p2) `M.equal` (c1 `compose` c2));
assert (mk_carrier len offset s2 (p1 `P.sum_perm` p2) `M.equal` (c1 `compose` c2));
mk_carrier_inj len offset s1 s2 (p1 `P.sum_perm` p2) (p1 `P.sum_perm` p2)
let mk_carrier_valid_sum_perm
(#elt: Type)
(len: nat)
(offset: nat)
(s: Seq.seq elt)
(p1 p2: P.perm)
: Lemma
(let c1 = mk_carrier len offset s p1 in
let c2 = mk_carrier len offset s p2 in
composable c1 c2 <==> valid_sum_perm len offset (Seq.length s) p1 p2)
= let c1 = mk_carrier len offset s p1 in
let c2 = mk_carrier len offset s p2 in
if Seq.length s > 0 && offset + Seq.length s <= len
then
let open FStar.Real in
assert (P.composable (M.sel c1 offset) (M.sel c2 offset) <==> valid_perm len offset (Seq.length s) (P.sum_perm p1 p2))
else ()
let gather
a #x1 p1 #x2 p2
= elim_pts_to a p1 x1;
elim_pts_to a p2 x2;
let _ = R.gather (ptr_of a).base
(mk_carrier (US.v (ptr_of a).base_len) ((ptr_of a).offset) x1 p1)
(mk_carrier (US.v (ptr_of a).base_len) ((ptr_of a).offset) x2 p2)
in
mk_carrier_gather (US.v (ptr_of a).base_len) ((ptr_of a).offset) x1 x2 p1 p2;
mk_carrier_valid_sum_perm (US.v (ptr_of a).base_len) ((ptr_of a).offset) x1 p1 p2;
intro_pts_to a (p1 `P.sum_perm` p2) x1
#push-options "--z3rlimit 16"
[@@noextract_to "krml"]
let index0
(#t: Type) (#p: P.perm)
(a: array t)
(#s: Ghost.erased (Seq.seq t))
(i: US.t)
: ST t
(pts_to a p s)
(fun _ -> pts_to a p s)
(US.v i < length a \/ US.v i < Seq.length s)
(fun res -> Seq.length s == length a /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i))
= elim_pts_to a p s;
let s' = R.read (ptr_of a).base _ in
let res = fst (Some?.v (M.sel s' ((ptr_of a).offset + US.v i))) in
intro_pts_to a p s;
return res
#pop-options
let index_ptr a i =
index0 _ i
let mk_carrier_upd
(#elt: Type)
(len: nat)
(offset: nat)
(s: Seq.seq elt)
(i: nat)
(v: elt)
(_: squash (
offset + Seq.length s <= len /\
i < Seq.length s
))
: Lemma
(ensures (
let o = mk_carrier len offset s P.full_perm in
let o' = mk_carrier len offset (Seq.upd s i v) P.full_perm in
o' `Map.equal` Map.upd o (offset + i) (Some (v, P.full_perm))
))
= ()
#push-options "--z3rlimit 20"
[@@noextract_to "krml"]
let upd0
(#t: Type)
(a: array t)
(#s: Ghost.erased (Seq.seq t))
(i: US.t { US.v i < Seq.length s })
(v: t)
: STT unit
(pts_to a P.full_perm s)
(fun res -> pts_to a P.full_perm (Seq.upd s (US.v i) v))
= elim_pts_to a _ _;
mk_carrier_upd (US.v (ptr_of a).base_len) ((ptr_of a).offset) s (US.v i) v ();
R.upd_gen
(ptr_of a).base
_ _
(PM.lift_frame_preserving_upd
_ _
(P.mk_frame_preserving_upd
(Seq.index s (US.v i))
v
)
_ ((ptr_of a).offset + US.v i)
);
intro_pts_to a _ _
#pop-options
let upd_ptr a i v =
upd0 _ i v;
rewrite
(pts_to _ _ _)
(pts_to _ _ _)
let mk_carrier_merge
(#elt: Type)
(len: nat)
(offset: nat)
(s1 s2: Seq.seq elt)
(p: P.perm)
: Lemma
(requires (
offset + Seq.length s1 + Seq.length s2 <= len
))
(ensures (
let c1 = mk_carrier len offset s1 p in
let c2 = mk_carrier len (offset + Seq.length s1) s2 p in
composable c1 c2 /\
mk_carrier len offset (s1 `Seq.append` s2) p `M.equal` (c1 `compose` c2)
))
= () | {
"checked_file": "/",
"dependencies": [
"Steel.ST.PCMReference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.PCMMap.fst.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.HigherArray.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.PCMMap",
"short_module": "PM"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Steel.ST.PCMReference",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "Steel.PCMFrac",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.PtrdiffT",
"short_module": "UP"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": 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 |
a1: Steel.ST.HigherArray.array elt ->
a2: Steel.ST.HigherArray.array elt ->
h: Prims.squash (Steel.ST.HigherArray.adjacent a1 a2)
-> Steel.ST.Effect.Ghost.STGhostT Prims.unit | Steel.ST.Effect.Ghost.STGhostT | [] | [] | [
"Steel.Memory.inames",
"FStar.Seq.Base.seq",
"Steel.FractionalPermission.perm",
"Steel.ST.HigherArray.array",
"Prims.squash",
"Steel.ST.HigherArray.adjacent",
"Steel.ST.HigherArray.intro_pts_to",
"Steel.ST.HigherArray.merge",
"FStar.Ghost.hide",
"Steel.ST.HigherArray.mk_carrier",
"FStar.SizeT.v",
"FStar.Ghost.reveal",
"FStar.SizeT.t",
"Steel.ST.HigherArray.__proj__Mkptr__item__base_len",
"Steel.ST.HigherArray.ptr_of",
"Steel.ST.HigherArray.__proj__Mkptr__item__offset",
"FStar.Seq.Base.append",
"Prims.unit",
"Steel.ST.HigherArray.change_r_pts_to",
"Steel.ST.HigherArray.carrier",
"Prims.nat",
"Steel.ST.HigherArray.pcm",
"Steel.ST.HigherArray.__proj__Mkptr__item__base",
"FStar.PCM.op",
"Prims.op_Addition",
"FStar.Seq.Base.length",
"Steel.ST.PCMReference.gather",
"FStar.PCM.composable",
"Steel.ST.HigherArray.mk_carrier_merge",
"Steel.ST.HigherArray.elim_pts_to"
] | [] | false | true | false | false | false | let ghost_join #_ #_ #x1 #x2 #p a1 a2 h =
| elim_pts_to a1 p x1;
elim_pts_to a2 p x2;
mk_carrier_merge (US.v (ptr_of a1).base_len) ((ptr_of a1).offset) x1 x2 (p);
change_r_pts_to (ptr_of a2).base
_
(ptr_of a1).base
(mk_carrier (US.v (ptr_of a1).base_len) ((ptr_of a1).offset + Seq.length x1) x2 p);
R.gather (ptr_of a1).base
(mk_carrier (US.v (ptr_of a1).base_len) ((ptr_of a1).offset) x1 (p))
(mk_carrier (US.v (ptr_of a1).base_len) ((ptr_of a1).offset + Seq.length x1) x2 (p));
change_r_pts_to (ptr_of a1).base
_
(ptr_of (merge a1 a2)).base
(mk_carrier (US.v (ptr_of (merge a1 a2)).base_len)
((ptr_of (merge a1 a2)).offset)
(x1 `Seq.append` x2)
(p));
intro_pts_to (merge a1 a2) p (Seq.append x1 x2) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index | val index: #ty: Type -> s: seq ty -> i: nat{i < length s} -> ty | val index: #ty: Type -> s: seq ty -> i: nat{i < length s} -> ty | let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 73,
"start_col": 0,
"start_line": 72
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T; | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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.Sequence.Base.seq ty -> i: Prims.nat{i < FStar.Sequence.Base.length s} -> ty | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.List.Tot.Base.index"
] | [] | false | false | false | false | false | let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
| FLT.index s i | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.equal | val equal: #ty: Type -> seq ty -> seq ty -> Type0 | val equal: #ty: Type -> seq ty -> seq ty -> Type0 | let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 126,
"start_col": 0,
"start_line": 123
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool; | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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 | s0: FStar.Sequence.Base.seq ty -> s1: FStar.Sequence.Base.seq ty -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Sequence.Base.length",
"Prims.l_Forall",
"Prims.int",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThan",
"Prims.l_imp",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.index"
] | [] | false | false | false | true | true | let equal (#ty: Type) (s0 s1: seq ty) : Type0 =
| length s0 == length s1 /\
(forall j. {:pattern index s0 j\/index s1 j} 0 <= j && j < length s0 ==> index s0 j == index s1 j) | false |
Hacl.HPKE.Curve64_CP256_SHA512.fsti | Hacl.HPKE.Curve64_CP256_SHA512.cs | val cs:S.ciphersuite | val cs:S.ciphersuite | let cs:S.ciphersuite = (DH.DH_Curve25519, Hash.SHA2_256, S.Seal AEAD.CHACHA20_POLY1305, Hash.SHA2_512) | {
"file_name": "code/hpke/Hacl.HPKE.Curve64_CP256_SHA512.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 102,
"end_line": 10,
"start_col": 0,
"start_line": 10
} | module Hacl.HPKE.Curve64_CP256_SHA512
open Hacl.Impl.HPKE
module S = Spec.Agile.HPKE
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash | {
"checked_file": "/",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Spec.Agile.HPKE.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Hacl.Impl.HPKE.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.HPKE.Curve64_CP256_SHA512.fsti"
} | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"abbrev": true,
"full_module": "Spec.Agile.HPKE",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.HPKE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | Spec.Agile.HPKE.ciphersuite | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.Mktuple4",
"Spec.Agile.DH.algorithm",
"Spec.Agile.HPKE.hash_algorithm",
"Spec.Agile.HPKE.aead",
"Spec.Hash.Definitions.hash_alg",
"Spec.Agile.DH.DH_Curve25519",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Agile.HPKE.Seal",
"Spec.Agile.AEAD.CHACHA20_POLY1305",
"Spec.Hash.Definitions.SHA2_512"
] | [] | false | false | false | true | false | let cs:S.ciphersuite =
| (DH.DH_Curve25519, Hash.SHA2_256, S.Seal AEAD.CHACHA20_POLY1305, Hash.SHA2_512) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_left_identity_aux | val matrix_left_identity_aux
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1))
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_mul_unit add mul m) i k) `mul.mult` (ijth mx k j)
)))
`eq.eq`
(if k > i then ijth mx i j else add.unit)) (decreases k) | val matrix_left_identity_aux
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1))
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_mul_unit add mul m) i k) `mul.mult` (ijth mx k j)
)))
`eq.eq`
(if k > i then ijth mx i j else add.unit)) (decreases k) | let matrix_left_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` (if k>i then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_left_mul_identity_aux_0 add mul mx i j k
else if k <= i then matrix_left_mul_identity_aux_1 add mul mx i j k
else if k = i+1 then matrix_left_mul_identity_aux_2 add mul mx i j k
else matrix_left_mul_identity_aux_3 add mul mx i j k | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 54,
"end_line": 1028,
"start_col": 0,
"start_line": 1016
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit
let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_right_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1){k>j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j)
(decreases k) =
if (k-1) > j+1 then matrix_right_mul_identity_aux_3 add mul mx i j (k-1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k-1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let subgen (i: under (k)) = gen i in
let full = SB.init k gen in
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_right_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq`
(if k>j then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else if k <= j then matrix_right_mul_identity_aux_1 add mul mx i j k
else if k = j+1 then matrix_right_mul_identity_aux_2 add mul mx i j k
else matrix_right_mul_identity_aux_3 add mul mx i j k
let matrix_left_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) = eq.reflexivity add.unit
let rec matrix_left_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=i /\ k>0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
if k=1 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
SP.foldm_snoc_decomposition add full;
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
#push-options "--z3rlimit 20"
let matrix_left_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
assert (k-1 <= i /\ k-1 >= 0);
if (k-1)=0 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_left_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under(m+1){k>i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
if (k-1 = i+1) then matrix_left_mul_identity_aux_2 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_3 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: FStar.IntegerIntervals.under (m + 1)
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc add
(FStar.Seq.Base.init k
(fun k ->
CM?.mult mul
(FStar.Matrix.ijth (FStar.Matrix.matrix_mul_unit add mul m) i k)
(FStar.Matrix.ijth mx k j))))
(match k > i with
| true -> FStar.Matrix.ijth mx i j
| _ -> CM?.unit add)) (decreases k) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.op_Addition",
"Prims.op_Equality",
"Prims.int",
"FStar.Matrix.matrix_left_mul_identity_aux_0",
"Prims.bool",
"Prims.op_LessThanOrEqual",
"FStar.Matrix.matrix_left_mul_identity_aux_1",
"FStar.Matrix.matrix_left_mul_identity_aux_2",
"FStar.Matrix.matrix_left_mul_identity_aux_3",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Matrix.ijth",
"FStar.Matrix.matrix_mul_unit",
"Prims.op_GreaterThan",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let matrix_left_identity_aux
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: under (m + 1))
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_mul_unit add mul m) i k) `mul.mult` (ijth mx k j)
)))
`eq.eq`
(if k > i then ijth mx i j else add.unit)) (decreases k) =
| if k = 0
then matrix_left_mul_identity_aux_0 add mul mx i j k
else
if k <= i
then matrix_left_mul_identity_aux_1 add mul mx i j k
else
if k = i + 1
then matrix_left_mul_identity_aux_2 add mul mx i j k
else matrix_left_mul_identity_aux_3 add mul mx i j k | false |
FStar.Matrix.fst | FStar.Matrix.matrix_right_mul_identity_aux_1 | val matrix_right_mul_identity_aux_1
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k <= j})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)
)))
`eq.eq`
add.unit) (decreases k) | val matrix_right_mul_identity_aux_1
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k <= j})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)
)))
`eq.eq`
add.unit) (decreases k) | let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 826,
"start_col": 0,
"start_line": 792
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: Prims.nat{k <= j}
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc add
(FStar.Seq.Base.init k
(fun k ->
CM?.mult mul
(FStar.Matrix.ijth mx i k)
(FStar.Matrix.ijth (FStar.Matrix.matrix_mul_unit add mul m) k j))))
(CM?.unit add)) (decreases k) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"FStar.Matrix.matrix_right_mul_identity_aux_0",
"Prims.bool",
"FStar.Seq.Base.seq",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"Prims.unit",
"FStar.Seq.Permutation.foldm_snoc_decomposition",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__identity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Matrix.matrix_mul_unit_ijth",
"Prims.op_Subtraction",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Seq.Base.init",
"FStar.Matrix.liat_equals_init",
"FStar.Matrix.matrix_right_mul_identity_aux_1",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc",
"FStar.Matrix.ijth",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.matrix_mul",
"FStar.Matrix.matrix_mul_unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec matrix_right_mul_identity_aux_1
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: nat{k <= j})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)
)))
`eq.eq`
add.unit) (decreases k) =
| if k = 0
then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat, last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k - 1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat) (add.unit * SP.foldm_snoc add liat) (add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k - 1) gen));
matrix_mul_unit_ijth add mul m (k - 1) j;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult add.unit add.unit) add.unit | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.update | val update: #ty: Type -> s: seq ty -> i: nat{i < length s} -> ty -> seq ty | val update: #ty: Type -> s: seq ty -> i: nat{i < length s} -> ty -> seq ty | let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 94,
"start_col": 0,
"start_line": 92
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T; | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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.Sequence.Base.seq ty -> i: Prims.nat{i < FStar.Sequence.Base.length s} -> v: ty
-> FStar.Sequence.Base.seq ty | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.list",
"FStar.Sequence.Base.append",
"Prims.Cons",
"Prims.Nil",
"FStar.Pervasives.Native.tuple3",
"FStar.List.Tot.Base.split3"
] | [] | false | false | false | false | false | let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
| let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2) | false |
FStar.Matrix.fst | FStar.Matrix.dot_of_equal_sequences | val dot_of_equal_sequences
(#c #eq: _)
(add mul: CE.cm c eq)
(m: _)
(p q r s: (z: SB.seq c {SB.length z == m}))
: Lemma (requires eq_of_seq eq p r /\ eq_of_seq eq q s)
(ensures eq.eq (dot add mul p q) (dot add mul r s)) | val dot_of_equal_sequences
(#c #eq: _)
(add mul: CE.cm c eq)
(m: _)
(p q r s: (z: SB.seq c {SB.length z == m}))
: Lemma (requires eq_of_seq eq p r /\ eq_of_seq eq q s)
(ensures eq.eq (dot add mul p q) (dot add mul r s)) | let dot_of_equal_sequences #c #eq (add mul: CE.cm c eq) m
(p q r s: (z:SB.seq c{SB.length z == m}))
: Lemma (requires eq_of_seq eq p r /\ eq_of_seq eq q s)
(ensures eq.eq (dot add mul p q) (dot add mul r s)) =
eq_of_seq_element_equality eq p r;
eq_of_seq_element_equality eq q s;
let aux (i: under (SB.length p)) : Lemma (SB.index (seq_of_products mul p q) i `eq.eq`
SB.index (seq_of_products mul r s) i)
= mul.congruence (SB.index p i) (SB.index q i) (SB.index r i) (SB.index s i)
in Classical.forall_intro aux;
eq_of_seq_from_element_equality eq (seq_of_products mul p q) (seq_of_products mul r s);
SP.foldm_snoc_equality add (seq_of_products mul p q) (seq_of_products mul r s) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 80,
"end_line": 1081,
"start_col": 0,
"start_line": 1070
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit
let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_right_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1){k>j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j)
(decreases k) =
if (k-1) > j+1 then matrix_right_mul_identity_aux_3 add mul mx i j (k-1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k-1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let subgen (i: under (k)) = gen i in
let full = SB.init k gen in
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_right_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq`
(if k>j then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else if k <= j then matrix_right_mul_identity_aux_1 add mul mx i j k
else if k = j+1 then matrix_right_mul_identity_aux_2 add mul mx i j k
else matrix_right_mul_identity_aux_3 add mul mx i j k
let matrix_left_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) = eq.reflexivity add.unit
let rec matrix_left_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=i /\ k>0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
if k=1 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
SP.foldm_snoc_decomposition add full;
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
#push-options "--z3rlimit 20"
let matrix_left_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
assert (k-1 <= i /\ k-1 >= 0);
if (k-1)=0 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_left_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under(m+1){k>i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
if (k-1 = i+1) then matrix_left_mul_identity_aux_2 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_3 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_left_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` (if k>i then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_left_mul_identity_aux_0 add mul mx i j k
else if k <= i then matrix_left_mul_identity_aux_1 add mul mx i j k
else if k = i+1 then matrix_left_mul_identity_aux_2 add mul mx i j k
else matrix_left_mul_identity_aux_3 add mul mx i j k
let matrix_mul_right_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `matrix_eq_fun eq` mx) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : Lemma (ijth mxu i j $=$ ijth mx i j) =
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx unit i j gen;
let seq = SB.init m gen in
matrix_right_identity_aux add mul mx i j m
in Classical.forall_intro_2 aux;
matrix_equiv_from_element_eq eq mxu mx
let matrix_mul_left_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul (matrix_mul_unit add mul m) mx `matrix_eq_fun eq` mx) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul unit mx in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : squash (ijth mxu i j $=$ ijth mx i j) =
let gen (k: under m) = ijth unit i k * ijth mx k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul unit mx i j gen;
let seq = SB.init m gen in
matrix_left_identity_aux add mul mx i j m
in
matrix_equiv_from_proof eq mxu mx aux
let matrix_mul_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `matrix_eq_fun eq` mx /\
matrix_mul add mul (matrix_mul_unit add mul m) mx `matrix_eq_fun eq` mx) =
matrix_mul_left_identity add mul mx;
matrix_mul_right_identity add mul mx | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
m: Prims.nat ->
p: z: FStar.Seq.Base.seq c {FStar.Seq.Base.length z == m} ->
q: z: FStar.Seq.Base.seq c {FStar.Seq.Base.length z == m} ->
r: z: FStar.Seq.Base.seq c {FStar.Seq.Base.length z == m} ->
s: z: FStar.Seq.Base.seq c {FStar.Seq.Base.length z == m}
-> FStar.Pervasives.Lemma
(requires FStar.Seq.Equiv.eq_of_seq eq p r /\ FStar.Seq.Equiv.eq_of_seq eq q s)
(ensures EQ?.eq eq (FStar.Matrix.dot add mul p q) (FStar.Matrix.dot add mul r s)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"FStar.Algebra.CommMonoid.Equiv.cm",
"Prims.nat",
"FStar.Seq.Base.seq",
"Prims.eq2",
"FStar.Seq.Base.length",
"FStar.Seq.Permutation.foldm_snoc_equality",
"FStar.Matrix.seq_of_products",
"Prims.unit",
"FStar.Seq.Equiv.eq_of_seq_from_element_equality",
"FStar.Classical.forall_intro",
"FStar.IntegerIntervals.under",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Base.index",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Seq.Equiv.eq_of_seq_element_equality",
"Prims.l_and",
"FStar.Seq.Equiv.eq_of_seq",
"FStar.Matrix.dot"
] | [] | false | false | true | false | false | let dot_of_equal_sequences
#c
#eq
(add: CE.cm c eq)
(mul: CE.cm c eq)
m
(p: (z: SB.seq c {SB.length z == m}))
(q: (z: SB.seq c {SB.length z == m}))
(r: (z: SB.seq c {SB.length z == m}))
(s: (z: SB.seq c {SB.length z == m}))
: Lemma (requires eq_of_seq eq p r /\ eq_of_seq eq q s)
(ensures eq.eq (dot add mul p q) (dot add mul r s)) =
| eq_of_seq_element_equality eq p r;
eq_of_seq_element_equality eq q s;
let aux (i: under (SB.length p))
: Lemma ((SB.index (seq_of_products mul p q) i) `eq.eq` (SB.index (seq_of_products mul r s) i))
=
mul.congruence (SB.index p i) (SB.index q i) (SB.index r i) (SB.index s i)
in
Classical.forall_intro aux;
eq_of_seq_from_element_equality eq (seq_of_products mul p q) (seq_of_products mul r s);
SP.foldm_snoc_equality add (seq_of_products mul p q) (seq_of_products mul r s) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.is_prefix | val is_prefix: #ty: Type -> seq ty -> seq ty -> Type0 | val is_prefix: #ty: Type -> seq ty -> seq ty -> Type0 | let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 137,
"start_col": 0,
"start_line": 134
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool; | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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 | s0: FStar.Sequence.Base.seq ty -> s1: FStar.Sequence.Base.seq ty -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Sequence.Base.seq",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.eq2",
"FStar.Sequence.Base.index"
] | [] | false | false | false | true | true | let is_prefix (#ty: Type) (s0 s1: seq ty) : Type0 =
| length s0 <= length s1 /\
(forall (j: nat). {:pattern index s0 j\/index s1 j} j < length s0 ==> index s0 j == index s1 j) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_right_mul_identity_aux_3 | val matrix_right_mul_identity_aux_3
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1) {k > j + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)
)))
`eq.eq`
(ijth mx i j)) (decreases k) | val matrix_right_mul_identity_aux_3
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1) {k > j + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)
)))
`eq.eq`
(ijth mx i j)) (decreases k) | let rec matrix_right_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1){k>j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j)
(decreases k) =
if (k-1) > j+1 then matrix_right_mul_identity_aux_3 add mul mx i j (k-1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k-1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let subgen (i: under (k)) = gen i in
let full = SB.init k gen in
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 893,
"start_col": 0,
"start_line": 859
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit
let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: FStar.IntegerIntervals.under (m + 1) {k > j + 1}
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc add
(FStar.Seq.Base.init k
(fun k ->
CM?.mult mul
(FStar.Matrix.ijth mx i k)
(FStar.Matrix.ijth (FStar.Matrix.matrix_mul_unit add mul m) k j))))
(FStar.Matrix.ijth mx i j)) (decreases k) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.op_Addition",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.seq",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"Prims.op_Subtraction",
"FStar.Matrix.ijth",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__identity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Matrix.matrix_mul_unit_ijth",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__commutativity",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc",
"FStar.Matrix.liat_equals_init",
"FStar.Seq.Permutation.foldm_snoc_decomposition",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.matrix_mul",
"FStar.Matrix.matrix_mul_unit",
"FStar.Matrix.matrix_right_mul_identity_aux_3",
"Prims.bool",
"FStar.Matrix.matrix_right_mul_identity_aux_2",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec matrix_right_mul_identity_aux_3
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: under (m + 1) {k > j + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)
)))
`eq.eq`
(ijth mx i j)) (decreases k) =
| if (k - 1) > j + 1
then matrix_right_mul_identity_aux_3 add mul mx i j (k - 1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k - 1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let subgen (i: under (k)) = gen i in
let full = SB.init k gen in
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat, last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k - 1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k - 1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k - 1) gen));
matrix_mul_unit_ijth add mul m (k - 1) j;
add.congruence last
(SP.foldm_snoc add (SB.init (k - 1) gen))
add.unit
(SP.foldm_snoc add (SB.init (k - 1) gen));
add.identity (SP.foldm_snoc add (SB.init (k - 1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k - 1) gen)))
(SP.foldm_snoc add (SB.init (k - 1) gen));
eq.transitivity (SP.foldm_snoc add full) (SP.foldm_snoc add (SB.init (k - 1) gen)) (ijth mx i j) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.append_sums_lengths_lemma | val append_sums_lengths_lemma: Prims.unit -> Lemma (append_sums_lengths_fact) | val append_sums_lengths_lemma: Prims.unit -> Lemma (append_sums_lengths_fact) | let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 188,
"start_col": 8,
"start_line": 184
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.append_sums_lengths_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.append",
"Prims.op_Addition",
"FStar.List.Tot.Properties.append_length",
"Prims.squash",
"Prims.l_True",
"FStar.Sequence.Base.append_sums_lengths_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
| introduce forall (ty: Type) (s0: seq ty) (s1: seq ty) . length (append s0 s1) =
length s0 + length s1
with (FLT.append_length s0 s1) | false |
Demo.Deps.fst | Demo.Deps.length | val length (#a: Type) (b: buffer a) : GTot U32.t | val length (#a: Type) (b: buffer a) : GTot U32.t | let length (#a:Type) (b:buffer a) : GTot U32.t =
U32.uint_to_t (B.length b) | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 33,
"start_col": 0,
"start_line": 32
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a
let buffer = B.buffer
let uint32 = U32.t
let uint8 = U8.t | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": 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 | b: Demo.Deps.buffer a -> Prims.GTot FStar.UInt32.t | Prims.GTot | [
"sometrivial"
] | [] | [
"Demo.Deps.buffer",
"FStar.UInt32.uint_to_t",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t"
] | [] | false | false | false | false | false | let length (#a: Type) (b: buffer a) : GTot U32.t =
| U32.uint_to_t (B.length b) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_right_identity | val matrix_mul_right_identity (#c:_) (#eq:_) (#m: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `(matrix_equiv eq m m).eq` mx) | val matrix_mul_right_identity (#c:_) (#eq:_) (#m: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `(matrix_equiv eq m m).eq` mx) | let matrix_mul_right_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `matrix_eq_fun eq` mx) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : Lemma (ijth mxu i j $=$ ijth mx i j) =
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx unit i j gen;
let seq = SB.init m gen in
matrix_right_identity_aux add mul mx i j m
in Classical.forall_intro_2 aux;
matrix_equiv_from_element_eq eq mxu mx | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 1044,
"start_col": 0,
"start_line": 1030
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit
let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_right_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1){k>j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j)
(decreases k) =
if (k-1) > j+1 then matrix_right_mul_identity_aux_3 add mul mx i j (k-1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k-1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let subgen (i: under (k)) = gen i in
let full = SB.init k gen in
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_right_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq`
(if k>j then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else if k <= j then matrix_right_mul_identity_aux_1 add mul mx i j k
else if k = j+1 then matrix_right_mul_identity_aux_2 add mul mx i j k
else matrix_right_mul_identity_aux_3 add mul mx i j k
let matrix_left_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) = eq.reflexivity add.unit
let rec matrix_left_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=i /\ k>0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
if k=1 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
SP.foldm_snoc_decomposition add full;
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
#push-options "--z3rlimit 20"
let matrix_left_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
assert (k-1 <= i /\ k-1 >= 0);
if (k-1)=0 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_left_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under(m+1){k>i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
if (k-1 = i+1) then matrix_left_mul_identity_aux_2 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_3 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_left_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` (if k>i then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_left_mul_identity_aux_0 add mul mx i j k
else if k <= i then matrix_left_mul_identity_aux_1 add mul mx i j k
else if k = i+1 then matrix_left_mul_identity_aux_2 add mul mx i j k
else matrix_left_mul_identity_aux_3 add mul mx i j k | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq (FStar.Matrix.matrix_equiv eq m m)
(FStar.Matrix.matrix_mul add mul mx (FStar.Matrix.matrix_mul_unit add mul m))
mx) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_element_eq",
"Prims.unit",
"FStar.Classical.forall_intro_2",
"FStar.IntegerIntervals.under",
"FStar.Matrix.ijth",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Matrix.matrix_right_identity_aux",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.init",
"FStar.Matrix.matrix_mul_ijth_eq_sum_of_seq_for_init",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Matrix.matrix_mul",
"FStar.Matrix.matrix_mul_unit",
"FStar.Matrix.matrix_eq_fun"
] | [] | false | false | true | false | false | let matrix_mul_right_identity
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_eq_fun eq (matrix_mul add mul mx (matrix_mul_unit add mul m)) mx) =
| let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : Lemma (ijth mxu i j $=$ ijth mx i j) =
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx unit i j gen;
let seq = SB.init m gen in
matrix_right_identity_aux add mul mx i j m
in
Classical.forall_intro_2 aux;
matrix_equiv_from_element_eq eq mxu mx | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_is_left_distributive | val matrix_mul_is_left_distributive (#c:_) (#eq:_) (#m #n #p:pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my mz: matrix c n p)
: Lemma (matrix_mul add mul mx (matrix_add add my mz) `(matrix_equiv eq m p).eq`
matrix_add add (matrix_mul add mul mx my) (matrix_mul add mul mx mz)) | val matrix_mul_is_left_distributive (#c:_) (#eq:_) (#m #n #p:pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my mz: matrix c n p)
: Lemma (matrix_mul add mul mx (matrix_add add my mz) `(matrix_equiv eq m p).eq`
matrix_add add (matrix_mul add mul mx my) (matrix_mul add mul mx mz)) | let matrix_mul_is_left_distributive #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my mz: matrix c n p)
: Lemma (matrix_mul add mul mx (matrix_add add my mz) `matrix_eq_fun eq`
matrix_add add (matrix_mul add mul mx my) (matrix_mul add mul mx mz)) =
let myz = matrix_add add my mz in
let mxy = matrix_mul add mul mx my in
let mxz = matrix_mul add mul mx mz in
let lhs = matrix_mul add mul mx myz in
let rhs = matrix_add add mxy mxz in
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let aux i k : Lemma (ijth lhs i k `eq.eq` ijth rhs i k) =
let init_lhs j = mul.mult (ijth mx i j) (ijth myz j k) in
let init_xy j = mul.mult (ijth mx i j) (ijth my j k) in
let init_xz j = mul.mult (ijth mx i j) (ijth mz j k) in
let init_rhs j = mul.mult (ijth mx i j) (ijth my j k) `add.mult`
mul.mult (ijth mx i j) (ijth mz j k) in
Classical.forall_intro eq.reflexivity;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i k init_lhs;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k init_xy;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx mz i k init_xz;
SP.foldm_snoc_split_seq add (SB.init n init_xy)
(SB.init n init_xz)
(SB.init n init_rhs)
(fun j -> ());
eq.symmetry (ijth rhs i k) (sum_j init_rhs);
SP.foldm_snoc_of_equal_inits add init_lhs init_rhs;
eq.transitivity (ijth lhs i k)
(sum_j init_rhs)
(ijth rhs i k)
in matrix_equiv_from_proof eq lhs rhs aux | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 1137,
"start_col": 0,
"start_line": 1106
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit
let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_right_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1){k>j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j)
(decreases k) =
if (k-1) > j+1 then matrix_right_mul_identity_aux_3 add mul mx i j (k-1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k-1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let subgen (i: under (k)) = gen i in
let full = SB.init k gen in
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_right_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq`
(if k>j then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else if k <= j then matrix_right_mul_identity_aux_1 add mul mx i j k
else if k = j+1 then matrix_right_mul_identity_aux_2 add mul mx i j k
else matrix_right_mul_identity_aux_3 add mul mx i j k
let matrix_left_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) = eq.reflexivity add.unit
let rec matrix_left_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=i /\ k>0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
if k=1 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
SP.foldm_snoc_decomposition add full;
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
#push-options "--z3rlimit 20"
let matrix_left_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
assert (k-1 <= i /\ k-1 >= 0);
if (k-1)=0 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_left_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under(m+1){k>i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
if (k-1 = i+1) then matrix_left_mul_identity_aux_2 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_3 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_left_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` (if k>i then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_left_mul_identity_aux_0 add mul mx i j k
else if k <= i then matrix_left_mul_identity_aux_1 add mul mx i j k
else if k = i+1 then matrix_left_mul_identity_aux_2 add mul mx i j k
else matrix_left_mul_identity_aux_3 add mul mx i j k
let matrix_mul_right_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `matrix_eq_fun eq` mx) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : Lemma (ijth mxu i j $=$ ijth mx i j) =
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx unit i j gen;
let seq = SB.init m gen in
matrix_right_identity_aux add mul mx i j m
in Classical.forall_intro_2 aux;
matrix_equiv_from_element_eq eq mxu mx
let matrix_mul_left_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul (matrix_mul_unit add mul m) mx `matrix_eq_fun eq` mx) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul unit mx in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : squash (ijth mxu i j $=$ ijth mx i j) =
let gen (k: under m) = ijth unit i k * ijth mx k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul unit mx i j gen;
let seq = SB.init m gen in
matrix_left_identity_aux add mul mx i j m
in
matrix_equiv_from_proof eq mxu mx aux
let matrix_mul_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `matrix_eq_fun eq` mx /\
matrix_mul add mul (matrix_mul_unit add mul m) mx `matrix_eq_fun eq` mx) =
matrix_mul_left_identity add mul mx;
matrix_mul_right_identity add mul mx
let dot_of_equal_sequences #c #eq (add mul: CE.cm c eq) m
(p q r s: (z:SB.seq c{SB.length z == m}))
: Lemma (requires eq_of_seq eq p r /\ eq_of_seq eq q s)
(ensures eq.eq (dot add mul p q) (dot add mul r s)) =
eq_of_seq_element_equality eq p r;
eq_of_seq_element_equality eq q s;
let aux (i: under (SB.length p)) : Lemma (SB.index (seq_of_products mul p q) i `eq.eq`
SB.index (seq_of_products mul r s) i)
= mul.congruence (SB.index p i) (SB.index q i) (SB.index r i) (SB.index s i)
in Classical.forall_intro aux;
eq_of_seq_from_element_equality eq (seq_of_products mul p q) (seq_of_products mul r s);
SP.foldm_snoc_equality add (seq_of_products mul p q) (seq_of_products mul r s)
let matrix_mul_congruence #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(mz: matrix c m n) (mw: matrix c n p)
: Lemma (requires matrix_eq_fun eq mx mz /\ matrix_eq_fun eq my mw)
(ensures matrix_eq_fun eq (matrix_mul add mul mx my) (matrix_mul add mul mz mw)) =
let aux (i: under m) (k: under p) : Lemma (ijth (matrix_mul add mul mx my) i k
`eq.eq` ijth (matrix_mul add mul mz mw) i k) =
let init_xy (j: under n) = mul.mult (ijth mx i j) (ijth my j k) in
let init_zw (j: under n) = mul.mult (ijth mz i j) (ijth mw j k) in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k init_xy;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mz mw i k init_zw;
let sp_xy = SB.init n init_xy in
let sp_zw = SB.init n init_zw in
let all_eq (j: under n) : Lemma (init_xy j `eq.eq` init_zw j) =
matrix_equiv_ijth eq mx mz i j;
matrix_equiv_ijth eq my mw j k;
mul.congruence (ijth mx i j) (ijth my j k) (ijth mz i j) (ijth mw j k)
in Classical.forall_intro all_eq;
eq_of_seq_from_element_equality eq sp_xy sp_zw;
SP.foldm_snoc_equality add sp_xy sp_zw
in matrix_equiv_from_proof eq (matrix_mul add mul mx my) (matrix_mul add mul mz mw) aux | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul:
FStar.Algebra.CommMonoid.Equiv.cm c eq
{FStar.Matrix.is_fully_distributive mul add /\ FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m n ->
my: FStar.Matrix.matrix c n p ->
mz: FStar.Matrix.matrix c n p
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq (FStar.Matrix.matrix_equiv eq m p)
(FStar.Matrix.matrix_mul add mul mx (FStar.Matrix.matrix_add add my mz))
(FStar.Matrix.matrix_add add
(FStar.Matrix.matrix_mul add mul mx my)
(FStar.Matrix.matrix_mul add mul mx mz))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"Prims.l_and",
"FStar.Matrix.is_fully_distributive",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_proof",
"FStar.IntegerIntervals.under",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.ijth",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Seq.Permutation.foldm_snoc_of_equal_inits",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__symmetry",
"FStar.Seq.Permutation.foldm_snoc_split_seq",
"FStar.Seq.Base.init",
"FStar.Seq.Base.length",
"FStar.Matrix.matrix_mul_ijth_eq_sum_of_seq_for_init",
"FStar.Classical.forall_intro",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Matrix.matrix_of",
"FStar.Matrix.matrix_add_generator",
"FStar.Matrix.matrix_add",
"FStar.Matrix.matrix_mul",
"FStar.Matrix.matrix_eq_fun"
] | [] | false | false | true | false | false | let matrix_mul_is_left_distributive
#c
#eq
#m
#n
#p
(add: CE.cm c eq)
(mul: CE.cm c eq {is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n)
(my: matrix c n p)
(mz: matrix c n p)
: Lemma
(matrix_eq_fun eq
(matrix_mul add mul mx (matrix_add add my mz))
(matrix_add add (matrix_mul add mul mx my) (matrix_mul add mul mx mz))) =
| let myz = matrix_add add my mz in
let mxy = matrix_mul add mul mx my in
let mxz = matrix_mul add mul mx mz in
let lhs = matrix_mul add mul mx myz in
let rhs = matrix_add add mxy mxz in
let sum_j (f: (under n -> c)) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: (under p -> c)) = SP.foldm_snoc add (SB.init p f) in
let aux i k : Lemma ((ijth lhs i k) `eq.eq` (ijth rhs i k)) =
let init_lhs j = mul.mult (ijth mx i j) (ijth myz j k) in
let init_xy j = mul.mult (ijth mx i j) (ijth my j k) in
let init_xz j = mul.mult (ijth mx i j) (ijth mz j k) in
let init_rhs j =
(mul.mult (ijth mx i j) (ijth my j k)) `add.mult` (mul.mult (ijth mx i j) (ijth mz j k))
in
Classical.forall_intro eq.reflexivity;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i k init_lhs;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k init_xy;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx mz i k init_xz;
SP.foldm_snoc_split_seq add
(SB.init n init_xy)
(SB.init n init_xz)
(SB.init n init_rhs)
(fun j -> ());
eq.symmetry (ijth rhs i k) (sum_j init_rhs);
SP.foldm_snoc_of_equal_inits add init_lhs init_rhs;
eq.transitivity (ijth lhs i k) (sum_j init_rhs) (ijth rhs i k)
in
matrix_equiv_from_proof eq lhs rhs aux | false |
Demo.Deps.fst | Demo.Deps.suffix | val suffix (#a: Type) (b: buffer a) (from: U32.t) (len: U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h -> U32.v from + U32.v len <= U32.v (length b) /\ live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from))) | val suffix (#a: Type) (b: buffer a) (from: U32.t) (len: U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h -> U32.v from + U32.v len <= U32.v (length b) /\ live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from))) | let suffix (#a:Type)
(b:buffer a)
(from:U32.t)
(len:U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h ->
U32.v from + U32.v len <= U32.v (length b) /\
live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from)))
= B.sub b from (len -^ from) | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 69,
"start_col": 0,
"start_line": 60
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a
let buffer = B.buffer
let uint32 = U32.t
let uint8 = U8.t
unfold
let length (#a:Type) (b:buffer a) : GTot U32.t =
U32.uint_to_t (B.length b)
unfold
let modifies (b:B.buffer 'a) h0 h1 = modifies (loc_buffer b) h0 h1
unfold
let live h (b:buffer 'a) = B.live h b
unfold
let ( .() ) (b:buffer 'a) (i:U32.t)
: ST 'a (requires fun h -> live h b /\ i <^ length b)
(ensures (fun h y h' -> h == h' /\ y == Seq.index (as_seq h b) (U32.v i)))
= B.index b i
unfold
let ( .()<- ) (b:buffer 'a) (i:U32.t) (v:'a)
: ST unit
(requires (fun h ->
live h b /\
i <^ length b))
(ensures (fun h _ h' ->
modifies b h h' /\
live h' b /\
as_seq h' b == Seq.upd (as_seq h b) (U32.v i) v))
= B.upd b i v | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": 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 |
b: Demo.Deps.buffer a ->
from: FStar.UInt32.t ->
len: FStar.UInt32.t{len <=^ Demo.Deps.length b /\ from <=^ len}
-> FStar.HyperStack.ST.ST (Demo.Deps.buffer a) | FStar.HyperStack.ST.ST | [] | [] | [
"Demo.Deps.buffer",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"FStar.UInt32.op_Less_Equals_Hat",
"Demo.Deps.length",
"LowStar.Buffer.sub",
"FStar.Ghost.hide",
"FStar.UInt32.op_Subtraction_Hat",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"FStar.Monotonic.HyperStack.mem",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.UInt32.v",
"Demo.Deps.live",
"Prims.eq2",
"LowStar.Monotonic.Buffer.mgsub"
] | [] | false | true | false | false | false | let suffix (#a: Type) (b: buffer a) (from: U32.t) (len: U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h -> U32.v from + U32.v len <= U32.v (length b) /\ live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from))) =
| B.sub b from (len -^ from) | false |
Demo.Deps.fst | Demo.Deps.op_Subtraction | val op_Subtraction : x: FStar.UInt32.t ->
y: FStar.UInt32.t{FStar.UInt.size (FStar.UInt32.v x - FStar.UInt32.v y) FStar.UInt32.n}
-> FStar.UInt32.t | let op_Subtraction (x:U32.t)
(y:U32.t{FStar.UInt.size (v x - v y) U32.n})
= U32.(x -^ y) | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 97,
"start_col": 0,
"start_line": 95
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a
let buffer = B.buffer
let uint32 = U32.t
let uint8 = U8.t
unfold
let length (#a:Type) (b:buffer a) : GTot U32.t =
U32.uint_to_t (B.length b)
unfold
let modifies (b:B.buffer 'a) h0 h1 = modifies (loc_buffer b) h0 h1
unfold
let live h (b:buffer 'a) = B.live h b
unfold
let ( .() ) (b:buffer 'a) (i:U32.t)
: ST 'a (requires fun h -> live h b /\ i <^ length b)
(ensures (fun h y h' -> h == h' /\ y == Seq.index (as_seq h b) (U32.v i)))
= B.index b i
unfold
let ( .()<- ) (b:buffer 'a) (i:U32.t) (v:'a)
: ST unit
(requires (fun h ->
live h b /\
i <^ length b))
(ensures (fun h _ h' ->
modifies b h h' /\
live h' b /\
as_seq h' b == Seq.upd (as_seq h b) (U32.v i) v))
= B.upd b i v
unfold
let suffix (#a:Type)
(b:buffer a)
(from:U32.t)
(len:U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h ->
U32.v from + U32.v len <= U32.v (length b) /\
live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from)))
= B.sub b from (len -^ from)
unfold
let disjoint (b0 b1:B.buffer 'a) = B.disjoint b0 b1
let lbuffer (len:U32.t) (a:Type) = b:B.buffer a{len <=^ length b}
let prefix_equal (#l:uint32) (#a:Type)
(h:HS.mem)
(b1 b2: lbuffer l a)
(i:uint32{i <=^ l})
: prop
= forall (j:uint32). j <^ i ==>
B.get h b1 (U32.v j) == B.get h b2 (U32.v j)
unfold
let ( <= ) x y = U32.(x <=^ y)
unfold
let ( < ) x y = U32.(x <^ y)
let ( + ) (x:U32.t) (y:U32.t{FStar.UInt.size (v x + v y) U32.n}) = U32.(x +^ y) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": 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: FStar.UInt32.t ->
y: FStar.UInt32.t{FStar.UInt.size (FStar.UInt32.v x - FStar.UInt32.v y) FStar.UInt32.n}
-> FStar.UInt32.t | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt32.t",
"FStar.UInt.size",
"Prims.op_Subtraction",
"FStar.UInt32.v",
"FStar.UInt32.n",
"FStar.UInt32.op_Subtraction_Hat"
] | [] | false | false | false | false | false | let ( - ) (x: U32.t) (y: U32.t{FStar.UInt.size (v x - v y) U32.n}) =
| let open U32 in x -^ y | false |
|
Hacl.Impl.Ed25519.Ladder.fst | Hacl.Impl.Ed25519.Ladder.point_mul_noalloc | val point_mul_noalloc:
out:point
-> bscalar:lbuffer uint64 4ul
-> q:point ->
Stack unit
(requires fun h ->
live h bscalar /\ live h q /\ live h out /\
disjoint q out /\ disjoint q bscalar /\ disjoint out bscalar /\
F51.point_inv_t h q /\ F51.inv_ext_point (as_seq h q) /\
BD.bn_v h bscalar < pow2 256)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
F51.point_inv_t h1 out /\ F51.inv_ext_point (as_seq h1 out) /\
S.to_aff_point (F51.point_eval h1 out) ==
LE.exp_fw S.mk_ed25519_comm_monoid
(S.to_aff_point (F51.point_eval h0 q)) 256 (BD.bn_v h0 bscalar) 4) | val point_mul_noalloc:
out:point
-> bscalar:lbuffer uint64 4ul
-> q:point ->
Stack unit
(requires fun h ->
live h bscalar /\ live h q /\ live h out /\
disjoint q out /\ disjoint q bscalar /\ disjoint out bscalar /\
F51.point_inv_t h q /\ F51.inv_ext_point (as_seq h q) /\
BD.bn_v h bscalar < pow2 256)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
F51.point_inv_t h1 out /\ F51.inv_ext_point (as_seq h1 out) /\
S.to_aff_point (F51.point_eval h1 out) ==
LE.exp_fw S.mk_ed25519_comm_monoid
(S.to_aff_point (F51.point_eval h0 q)) 256 (BD.bn_v h0 bscalar) 4) | let point_mul_noalloc out bscalar q =
BE.lexp_fw_consttime 20ul 0ul mk_ed25519_concrete_ops
4ul (null uint64) q 4ul 256ul bscalar out | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Ladder.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 85,
"start_col": 0,
"start_line": 83
} | module Hacl.Impl.Ed25519.Ladder
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module BSeq = Lib.ByteSequence
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExponentiation
module PT = Hacl.Impl.PrecompTable
module SPT256 = Hacl.Spec.PrecompBaseTable256
module BD = Hacl.Bignum.Definitions
module SD = Hacl.Spec.Bignum.Definitions
module S = Spec.Ed25519
open Hacl.Impl.Ed25519.PointConstants
include Hacl.Impl.Ed25519.Group
include Hacl.Ed25519.PrecompTable
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let table_inv_w4 : BE.table_inv_t U64 20ul 16ul =
[@inline_let] let len = 20ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_ed25519_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len
inline_for_extraction noextract
let table_inv_w5 : BE.table_inv_t U64 20ul 32ul =
[@inline_let] let len = 20ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_ed25519_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
assert_norm (pow2 (v l) = v table_len);
BE.table_inv_precomp len ctx_len k l table_len
inline_for_extraction noextract
val convert_scalar: scalar:lbuffer uint8 32ul -> bscalar:lbuffer uint64 4ul ->
Stack unit
(requires fun h -> live h scalar /\ live h bscalar /\ disjoint scalar bscalar)
(ensures fun h0 _ h1 -> modifies (loc bscalar) h0 h1 /\
BD.bn_v h1 bscalar == BSeq.nat_from_bytes_le (as_seq h0 scalar))
let convert_scalar scalar bscalar =
let h0 = ST.get () in
Hacl.Spec.Bignum.Convert.bn_from_bytes_le_lemma #U64 32 (as_seq h0 scalar);
Hacl.Bignum.Convert.mk_bn_from_bytes_le true 32ul scalar bscalar
inline_for_extraction noextract
val point_mul_noalloc:
out:point
-> bscalar:lbuffer uint64 4ul
-> q:point ->
Stack unit
(requires fun h ->
live h bscalar /\ live h q /\ live h out /\
disjoint q out /\ disjoint q bscalar /\ disjoint out bscalar /\
F51.point_inv_t h q /\ F51.inv_ext_point (as_seq h q) /\
BD.bn_v h bscalar < pow2 256)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
F51.point_inv_t h1 out /\ F51.inv_ext_point (as_seq h1 out) /\
S.to_aff_point (F51.point_eval h1 out) ==
LE.exp_fw S.mk_ed25519_comm_monoid
(S.to_aff_point (F51.point_eval h0 q)) 256 (BD.bn_v h0 bscalar) 4) | {
"checked_file": "/",
"dependencies": [
"Spec.Exponentiation.fsti.checked",
"Spec.Ed25519.Lemmas.fsti.checked",
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"LowStar.Ignore.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.PrecompBaseTable256.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.Convert.fst.checked",
"Hacl.Impl.PrecompTable.fsti.checked",
"Hacl.Impl.MultiExponentiation.fsti.checked",
"Hacl.Impl.Exponentiation.fsti.checked",
"Hacl.Impl.Ed25519.PointNegate.fst.checked",
"Hacl.Impl.Ed25519.PointConstants.fst.checked",
"Hacl.Impl.Ed25519.Group.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Ed25519.PrecompTable.fsti.checked",
"Hacl.Bignum25519.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Convert.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Impl.Ed25519.Ladder.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Ed25519.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519.PointConstants",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": "SD"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum.Definitions",
"short_module": "BD"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.PrecompTable",
"short_module": "PT"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.MultiExponentiation",
"short_module": "ME"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Lib.Exponentiation",
"short_module": "LE"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
out: Hacl.Bignum25519.point ->
bscalar: Lib.Buffer.lbuffer Lib.IntTypes.uint64 4ul ->
q: Hacl.Bignum25519.point
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum25519.point",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Exponentiation.lexp_fw_consttime",
"Lib.IntTypes.U64",
"Hacl.Impl.Ed25519.Group.mk_ed25519_concrete_ops",
"Lib.Buffer.null",
"Lib.Buffer.MUT",
"Prims.unit"
] | [] | false | true | false | false | false | let point_mul_noalloc out bscalar q =
| BE.lexp_fw_consttime 20ul 0ul mk_ed25519_concrete_ops 4ul (null uint64) q 4ul 256ul bscalar out | false |
Demo.Deps.fst | Demo.Deps.free | val free (#a: Type0) (b: buffer a)
: ST unit
(requires fun h0 -> live h0 b /\ freeable b)
(ensures
(fun h0 _ h1 ->
(Map.domain (HS.get_hmap h1)) `Set.equal` (Map.domain (HS.get_hmap h0)) /\
(HS.get_tip h1) == (HS.get_tip h0) /\ B.modifies (loc_addr_of_buffer b) h0 h1 /\
HS.live_region h1 (frameOf b))) | val free (#a: Type0) (b: buffer a)
: ST unit
(requires fun h0 -> live h0 b /\ freeable b)
(ensures
(fun h0 _ h1 ->
(Map.domain (HS.get_hmap h1)) `Set.equal` (Map.domain (HS.get_hmap h0)) /\
(HS.get_tip h1) == (HS.get_tip h0) /\ B.modifies (loc_addr_of_buffer b) h0 h1 /\
HS.live_region h1 (frameOf b))) | let free (#a:Type0) (b:buffer a)
: ST unit
(requires fun h0 ->
live h0 b /\
freeable b)
(ensures (fun h0 _ h1 ->
Map.domain (HS.get_hmap h1) `Set.equal` Map.domain (HS.get_hmap h0) /\
(HS.get_tip h1) == (HS.get_tip h0) /\
B.modifies (loc_addr_of_buffer b) h0 h1 /\
HS.live_region h1 (frameOf b)))
= B.free b | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 11,
"end_line": 117,
"start_col": 0,
"start_line": 107
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a
let buffer = B.buffer
let uint32 = U32.t
let uint8 = U8.t
unfold
let length (#a:Type) (b:buffer a) : GTot U32.t =
U32.uint_to_t (B.length b)
unfold
let modifies (b:B.buffer 'a) h0 h1 = modifies (loc_buffer b) h0 h1
unfold
let live h (b:buffer 'a) = B.live h b
unfold
let ( .() ) (b:buffer 'a) (i:U32.t)
: ST 'a (requires fun h -> live h b /\ i <^ length b)
(ensures (fun h y h' -> h == h' /\ y == Seq.index (as_seq h b) (U32.v i)))
= B.index b i
unfold
let ( .()<- ) (b:buffer 'a) (i:U32.t) (v:'a)
: ST unit
(requires (fun h ->
live h b /\
i <^ length b))
(ensures (fun h _ h' ->
modifies b h h' /\
live h' b /\
as_seq h' b == Seq.upd (as_seq h b) (U32.v i) v))
= B.upd b i v
unfold
let suffix (#a:Type)
(b:buffer a)
(from:U32.t)
(len:U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h ->
U32.v from + U32.v len <= U32.v (length b) /\
live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from)))
= B.sub b from (len -^ from)
unfold
let disjoint (b0 b1:B.buffer 'a) = B.disjoint b0 b1
let lbuffer (len:U32.t) (a:Type) = b:B.buffer a{len <=^ length b}
let prefix_equal (#l:uint32) (#a:Type)
(h:HS.mem)
(b1 b2: lbuffer l a)
(i:uint32{i <=^ l})
: prop
= forall (j:uint32). j <^ i ==>
B.get h b1 (U32.v j) == B.get h b2 (U32.v j)
unfold
let ( <= ) x y = U32.(x <=^ y)
unfold
let ( < ) x y = U32.(x <^ y)
let ( + ) (x:U32.t) (y:U32.t{FStar.UInt.size (v x + v y) U32.n}) = U32.(x +^ y)
let op_Subtraction (x:U32.t)
(y:U32.t{FStar.UInt.size (v x - v y) U32.n})
= U32.(x -^ y)
let malloc (init:'a) (len:U32.t)
: ST (lbuffer len 'a)
(requires fun h -> malloc_pre HS.root len)
(ensures fun h0 b h1 ->
alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
freeable b)
= B.malloc HS.root init len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": 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 | b: Demo.Deps.buffer a -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"Demo.Deps.buffer",
"LowStar.Monotonic.Buffer.free",
"LowStar.Buffer.trivial_preorder",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Demo.Deps.live",
"LowStar.Monotonic.Buffer.freeable",
"FStar.Set.equal",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Map.domain",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap",
"Prims.eq2",
"FStar.Monotonic.HyperStack.get_tip",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_addr_of_buffer",
"Prims.b2t",
"FStar.Monotonic.HyperStack.live_region",
"LowStar.Monotonic.Buffer.frameOf"
] | [] | false | true | false | false | false | let free (#a: Type0) (b: buffer a)
: ST unit
(requires fun h0 -> live h0 b /\ freeable b)
(ensures
(fun h0 _ h1 ->
(Map.domain (HS.get_hmap h1)) `Set.equal` (Map.domain (HS.get_hmap h0)) /\
(HS.get_tip h1) == (HS.get_tip h0) /\ B.modifies (loc_addr_of_buffer b) h0 h1 /\
HS.live_region h1 (frameOf b))) =
| B.free b | false |
Demo.Deps.fst | Demo.Deps.prefix_equal | val prefix_equal (#l: uint32) (#a: Type) (h: HS.mem) (b1 b2: lbuffer l a) (i: uint32{i <=^ l})
: prop | val prefix_equal (#l: uint32) (#a: Type) (h: HS.mem) (b1 b2: lbuffer l a) (i: uint32{i <=^ l})
: prop | let prefix_equal (#l:uint32) (#a:Type)
(h:HS.mem)
(b1 b2: lbuffer l a)
(i:uint32{i <=^ l})
: prop
= forall (j:uint32). j <^ i ==>
B.get h b1 (U32.v j) == B.get h b2 (U32.v j) | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 82,
"start_col": 0,
"start_line": 76
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a
let buffer = B.buffer
let uint32 = U32.t
let uint8 = U8.t
unfold
let length (#a:Type) (b:buffer a) : GTot U32.t =
U32.uint_to_t (B.length b)
unfold
let modifies (b:B.buffer 'a) h0 h1 = modifies (loc_buffer b) h0 h1
unfold
let live h (b:buffer 'a) = B.live h b
unfold
let ( .() ) (b:buffer 'a) (i:U32.t)
: ST 'a (requires fun h -> live h b /\ i <^ length b)
(ensures (fun h y h' -> h == h' /\ y == Seq.index (as_seq h b) (U32.v i)))
= B.index b i
unfold
let ( .()<- ) (b:buffer 'a) (i:U32.t) (v:'a)
: ST unit
(requires (fun h ->
live h b /\
i <^ length b))
(ensures (fun h _ h' ->
modifies b h h' /\
live h' b /\
as_seq h' b == Seq.upd (as_seq h b) (U32.v i) v))
= B.upd b i v
unfold
let suffix (#a:Type)
(b:buffer a)
(from:U32.t)
(len:U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h ->
U32.v from + U32.v len <= U32.v (length b) /\
live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from)))
= B.sub b from (len -^ from)
unfold
let disjoint (b0 b1:B.buffer 'a) = B.disjoint b0 b1
let lbuffer (len:U32.t) (a:Type) = b:B.buffer a{len <=^ length b} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": 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 ->
b1: Demo.Deps.lbuffer l a ->
b2: Demo.Deps.lbuffer l a ->
i: Demo.Deps.uint32{i <=^ l}
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Demo.Deps.uint32",
"FStar.Monotonic.HyperStack.mem",
"Demo.Deps.lbuffer",
"Prims.b2t",
"FStar.UInt32.op_Less_Equals_Hat",
"Prims.l_Forall",
"Prims.l_imp",
"FStar.UInt32.op_Less_Hat",
"Prims.eq2",
"LowStar.Monotonic.Buffer.get",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.v",
"Prims.prop"
] | [] | false | false | false | false | true | let prefix_equal (#l: uint32) (#a: Type) (h: HS.mem) (b1 b2: lbuffer l a) (i: uint32{i <=^ l})
: prop =
| forall (j: uint32). j <^ i ==> B.get h b1 (U32.v j) == B.get h b2 (U32.v j) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.update_maintains_length_lemma | val update_maintains_length_lemma: Prims.unit -> Lemma (update_maintains_length_fact) | val update_maintains_length_lemma: Prims.unit -> Lemma (update_maintains_length_fact) | let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 231,
"start_col": 8,
"start_line": 226
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.update_maintains_length_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.op_Equality",
"FStar.Sequence.Base.update",
"FStar.Sequence.Base.update_maintains_length_helper",
"Prims.squash",
"Prims.l_True",
"FStar.Sequence.Base.update_maintains_length_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
| introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) . length (update s i v) =
length s
with (update_maintains_length_helper s i v) | false |
FStar.Matrix.fst | FStar.Matrix.double_foldm_snoc_transpose_lemma | val double_foldm_snoc_transpose_lemma
(#c #eq: _)
(#m #n: pos)
(cm: CE.cm c eq)
(f: (under m -> under n -> c))
: Lemma
((SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
)
`eq.eq`
(SP.foldm_snoc cm
(SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))
)) | val double_foldm_snoc_transpose_lemma
(#c #eq: _)
(#m #n: pos)
(cm: CE.cm c eq)
(f: (under m -> under n -> c))
: Lemma
((SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
)
`eq.eq`
(SP.foldm_snoc cm
(SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))
)) | let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 126,
"end_line": 642,
"start_col": 0,
"start_line": 606
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
cm: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
f: (_: FStar.IntegerIntervals.under m -> _: FStar.IntegerIntervals.under n -> c)
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.init m
(fun i ->
FStar.Seq.Permutation.foldm_snoc cm (FStar.Seq.Base.init n (fun j -> f i j)))))
(FStar.Seq.Permutation.foldm_snoc cm
(FStar.Seq.Base.init n
(fun j ->
FStar.Seq.Permutation.foldm_snoc cm (FStar.Seq.Base.init m (fun i -> f i j)))))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.IntegerIntervals.under",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"FStar.Matrix.foldm",
"Prims.unit",
"Prims._assert",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Seq.Base.lemma_eq_elim",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Classical.forall_intro",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Matrix.matrix_fold_equals_fold_of_seq_folds",
"Prims.l_and",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.op_Multiply",
"Prims.l_Forall",
"FStar.Seq.Base.index",
"FStar.Matrix.get_ij",
"FStar.Matrix.get_i",
"FStar.Matrix.get_j",
"FStar.Matrix.matrix_seq",
"FStar.Matrix.matrix_of",
"FStar.Matrix.init",
"FStar.Matrix.matrix_generator",
"FStar.Matrix.transposed_matrix_gen",
"FStar.Matrix.matrix_fold_equals_fold_of_transpose",
"FStar.Matrix.matrix_transpose_is_permutation",
"FStar.Classical.forall_intro_2",
"Prims.l_imp",
"FStar.Classical.move_requires_2",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__symmetry"
] | [] | false | false | true | false | false | let double_foldm_snoc_transpose_lemma
#c
#eq
(#m: pos)
(#n: pos)
(cm: CE.cm c eq)
(f: (under m -> under n -> c))
: Lemma
((SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
)
`eq.eq`
(SP.foldm_snoc cm
(SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))
)) =
| Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen:matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j)) =
SB.lemma_eq_elim (SB.init n (gen i)) (SB.init n (fun (j: under n) -> f i j))
in
Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert ((foldm cm mx_trans)
`eq.eq`
(SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j))) =
SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in
Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert ((foldm cm mx_trans)
`eq.eq`
(SP.foldm_snoc cm
(SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))));
eq.transitivity (SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm
(SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_left_mul_identity_aux_1 | val matrix_left_mul_identity_aux_1
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k <= i /\ k > 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_mul_unit add mul m) i k) `mul.mult` (ijth mx k j)))
)
`eq.eq`
add.unit) | val matrix_left_mul_identity_aux_1
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k <= i /\ k > 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_mul_unit add mul m) i k) `mul.mult` (ijth mx k j)))
)
`eq.eq`
add.unit) | let rec matrix_left_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=i /\ k>0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
if k=1 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
SP.foldm_snoc_decomposition add full;
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 947,
"start_col": 0,
"start_line": 919
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit
let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_right_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1){k>j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j)
(decreases k) =
if (k-1) > j+1 then matrix_right_mul_identity_aux_3 add mul mx i j (k-1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k-1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let subgen (i: under (k)) = gen i in
let full = SB.init k gen in
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_right_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq`
(if k>j then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else if k <= j then matrix_right_mul_identity_aux_1 add mul mx i j k
else if k = j+1 then matrix_right_mul_identity_aux_2 add mul mx i j k
else matrix_right_mul_identity_aux_3 add mul mx i j k
let matrix_left_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) = eq.reflexivity add.unit | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: Prims.nat{k <= i /\ k > 0}
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc add
(FStar.Seq.Base.init k
(fun k ->
CM?.mult mul
(FStar.Matrix.ijth (FStar.Matrix.matrix_mul_unit add mul m) i k)
(FStar.Matrix.ijth mx k j))))
(CM?.unit add)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"FStar.Seq.Base.seq",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__identity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Seq.Permutation.foldm_snoc_decomposition",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Matrix.liat_equals_init",
"Prims.op_Equality",
"Prims.int",
"FStar.Matrix.matrix_left_mul_identity_aux_0",
"Prims.op_Subtraction",
"Prims.bool",
"FStar.Matrix.matrix_left_mul_identity_aux_1",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc",
"FStar.Seq.Base.init",
"FStar.Matrix.ijth",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.matrix_mul",
"FStar.Matrix.matrix_mul_unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec matrix_left_mul_identity_aux_1
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: nat{k <= i /\ k > 0})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_mul_unit add mul m) i k) `mul.mult` (ijth mx k j)))
)
`eq.eq`
add.unit) =
| let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat, last = SProp.un_snoc full in
if k = 1
then matrix_left_mul_identity_aux_0 add mul mx i j (k - 1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k - 1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
SP.foldm_snoc_decomposition add full;
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat) (add.unit * SP.foldm_snoc add liat) (add.unit);
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
eq.transitivity (SP.foldm_snoc add full) (add.mult add.unit add.unit) add.unit | false |
Demo.Deps.fst | Demo.Deps.get | val get : h: FStar.Monotonic.HyperStack.mem ->
b: Demo.Deps.buffer 'a {Demo.Deps.live h b} ->
i: FStar.UInt32.t{i < Demo.Deps.length b}
-> Prims.GTot 'a | let get (h:HS.mem) (b:buffer 'a{ live h b }) (i:U32.t{ i < length b}) =
B.get h b (U32.v i) | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 120,
"start_col": 0,
"start_line": 119
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a
let buffer = B.buffer
let uint32 = U32.t
let uint8 = U8.t
unfold
let length (#a:Type) (b:buffer a) : GTot U32.t =
U32.uint_to_t (B.length b)
unfold
let modifies (b:B.buffer 'a) h0 h1 = modifies (loc_buffer b) h0 h1
unfold
let live h (b:buffer 'a) = B.live h b
unfold
let ( .() ) (b:buffer 'a) (i:U32.t)
: ST 'a (requires fun h -> live h b /\ i <^ length b)
(ensures (fun h y h' -> h == h' /\ y == Seq.index (as_seq h b) (U32.v i)))
= B.index b i
unfold
let ( .()<- ) (b:buffer 'a) (i:U32.t) (v:'a)
: ST unit
(requires (fun h ->
live h b /\
i <^ length b))
(ensures (fun h _ h' ->
modifies b h h' /\
live h' b /\
as_seq h' b == Seq.upd (as_seq h b) (U32.v i) v))
= B.upd b i v
unfold
let suffix (#a:Type)
(b:buffer a)
(from:U32.t)
(len:U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h ->
U32.v from + U32.v len <= U32.v (length b) /\
live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from)))
= B.sub b from (len -^ from)
unfold
let disjoint (b0 b1:B.buffer 'a) = B.disjoint b0 b1
let lbuffer (len:U32.t) (a:Type) = b:B.buffer a{len <=^ length b}
let prefix_equal (#l:uint32) (#a:Type)
(h:HS.mem)
(b1 b2: lbuffer l a)
(i:uint32{i <=^ l})
: prop
= forall (j:uint32). j <^ i ==>
B.get h b1 (U32.v j) == B.get h b2 (U32.v j)
unfold
let ( <= ) x y = U32.(x <=^ y)
unfold
let ( < ) x y = U32.(x <^ y)
let ( + ) (x:U32.t) (y:U32.t{FStar.UInt.size (v x + v y) U32.n}) = U32.(x +^ y)
let op_Subtraction (x:U32.t)
(y:U32.t{FStar.UInt.size (v x - v y) U32.n})
= U32.(x -^ y)
let malloc (init:'a) (len:U32.t)
: ST (lbuffer len 'a)
(requires fun h -> malloc_pre HS.root len)
(ensures fun h0 b h1 ->
alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
freeable b)
= B.malloc HS.root init len
let free (#a:Type0) (b:buffer a)
: ST unit
(requires fun h0 ->
live h0 b /\
freeable b)
(ensures (fun h0 _ h1 ->
Map.domain (HS.get_hmap h1) `Set.equal` Map.domain (HS.get_hmap h0) /\
(HS.get_tip h1) == (HS.get_tip h0) /\
B.modifies (loc_addr_of_buffer b) h0 h1 /\
HS.live_region h1 (frameOf b)))
= B.free b | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": 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 ->
b: Demo.Deps.buffer 'a {Demo.Deps.live h b} ->
i: FStar.UInt32.t{i < Demo.Deps.length b}
-> Prims.GTot 'a | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Demo.Deps.buffer",
"Demo.Deps.live",
"FStar.UInt32.t",
"Prims.b2t",
"Demo.Deps.op_Less",
"Demo.Deps.length",
"LowStar.Monotonic.Buffer.get",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.v"
] | [] | false | false | false | false | false | let get (h: HS.mem) (b: buffer 'a {live h b}) (i: U32.t{i < length b}) =
| B.get h b (U32.v i) | false |
|
Demo.Deps.fst | Demo.Deps.malloc | val malloc (init: 'a) (len: U32.t)
: ST (lbuffer len 'a)
(requires fun h -> malloc_pre HS.root len)
(ensures
fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\ freeable b) | val malloc (init: 'a) (len: U32.t)
: ST (lbuffer len 'a)
(requires fun h -> malloc_pre HS.root len)
(ensures
fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\ freeable b) | let malloc (init:'a) (len:U32.t)
: ST (lbuffer len 'a)
(requires fun h -> malloc_pre HS.root len)
(ensures fun h0 b h1 ->
alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\
freeable b)
= B.malloc HS.root init len | {
"file_name": "examples/demos/low-star/Demo.Deps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 105,
"start_col": 0,
"start_line": 99
} | (*
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 Demo.Deps
open LowStar.Buffer
open FStar.UInt32
module B = LowStar.Buffer
module U32 = FStar.UInt32
module U8 = FStar.UInt8
module HS = FStar.HyperStack
open FStar.HyperStack.ST
effect St (a:Type) = FStar.HyperStack.ST.St a
let buffer = B.buffer
let uint32 = U32.t
let uint8 = U8.t
unfold
let length (#a:Type) (b:buffer a) : GTot U32.t =
U32.uint_to_t (B.length b)
unfold
let modifies (b:B.buffer 'a) h0 h1 = modifies (loc_buffer b) h0 h1
unfold
let live h (b:buffer 'a) = B.live h b
unfold
let ( .() ) (b:buffer 'a) (i:U32.t)
: ST 'a (requires fun h -> live h b /\ i <^ length b)
(ensures (fun h y h' -> h == h' /\ y == Seq.index (as_seq h b) (U32.v i)))
= B.index b i
unfold
let ( .()<- ) (b:buffer 'a) (i:U32.t) (v:'a)
: ST unit
(requires (fun h ->
live h b /\
i <^ length b))
(ensures (fun h _ h' ->
modifies b h h' /\
live h' b /\
as_seq h' b == Seq.upd (as_seq h b) (U32.v i) v))
= B.upd b i v
unfold
let suffix (#a:Type)
(b:buffer a)
(from:U32.t)
(len:U32.t{len <=^ length b /\ from <=^ len})
: ST (buffer a)
(requires (fun h ->
U32.v from + U32.v len <= U32.v (length b) /\
live h b))
(ensures (fun h y h' -> h == h' /\ y == mgsub _ b from (len -^ from)))
= B.sub b from (len -^ from)
unfold
let disjoint (b0 b1:B.buffer 'a) = B.disjoint b0 b1
let lbuffer (len:U32.t) (a:Type) = b:B.buffer a{len <=^ length b}
let prefix_equal (#l:uint32) (#a:Type)
(h:HS.mem)
(b1 b2: lbuffer l a)
(i:uint32{i <=^ l})
: prop
= forall (j:uint32). j <^ i ==>
B.get h b1 (U32.v j) == B.get h b2 (U32.v j)
unfold
let ( <= ) x y = U32.(x <=^ y)
unfold
let ( < ) x y = U32.(x <^ y)
let ( + ) (x:U32.t) (y:U32.t{FStar.UInt.size (v x + v y) U32.n}) = U32.(x +^ y)
let op_Subtraction (x:U32.t)
(y:U32.t{FStar.UInt.size (v x - v y) U32.n})
= U32.(x -^ y) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Demo.Deps.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Demo",
"short_module": null
},
{
"abbrev": 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 | init: 'a -> len: FStar.UInt32.t -> FStar.HyperStack.ST.ST (Demo.Deps.lbuffer len 'a) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.UInt32.t",
"LowStar.Buffer.malloc",
"FStar.Monotonic.HyperHeap.root",
"LowStar.Monotonic.Buffer.mbuffer",
"LowStar.Buffer.trivial_preorder",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"LowStar.Monotonic.Buffer.length",
"FStar.UInt32.v",
"Prims.b2t",
"Prims.op_Negation",
"LowStar.Monotonic.Buffer.g_is_null",
"FStar.Monotonic.HyperHeap.rid",
"LowStar.Monotonic.Buffer.frameOf",
"LowStar.Monotonic.Buffer.freeable",
"Demo.Deps.lbuffer",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.malloc_pre",
"LowStar.Monotonic.Buffer.alloc_post_mem_common",
"FStar.Seq.Base.create"
] | [] | false | true | false | false | false | let malloc (init: 'a) (len: U32.t)
: ST (lbuffer len 'a)
(requires fun h -> malloc_pre HS.root len)
(ensures
fun h0 b h1 -> alloc_post_mem_common b h0 h1 (Seq.create (U32.v len) init) /\ freeable b) =
| B.malloc HS.root init len | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.build_contains_equiv_lemma | val build_contains_equiv_lemma: Prims.unit -> Lemma (build_contains_equiv_fact) | val build_contains_equiv_lemma: Prims.unit -> Lemma (build_contains_equiv_fact) | let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 296,
"start_col": 8,
"start_line": 290
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.build_contains_equiv_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.l_iff",
"FStar.Sequence.Base.contains",
"FStar.Sequence.Base.build",
"Prims.l_or",
"Prims.eq2",
"FStar.Sequence.Base.build_contains_equiv_helper",
"Prims.squash",
"Prims.l_True",
"FStar.Sequence.Base.build_contains_equiv_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
| introduce forall (ty: Type) (s: seq ty) (v: ty) (x: ty) . contains (build s v) x <==>
(v == x \/ contains s x)
with (build_contains_equiv_helper ty s v x) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_contains_equiv_exists_lemma | val take_contains_equiv_exists_lemma: Prims.unit -> Lemma (take_contains_equiv_exists_fact) | val take_contains_equiv_exists_lemma: Prims.unit -> Lemma (take_contains_equiv_exists_fact) | let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 346,
"start_col": 8,
"start_line": 340
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.take_contains_equiv_exists_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.l_iff",
"FStar.Sequence.Base.contains",
"FStar.Sequence.Base.take",
"Prims.l_Exists",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.eq2",
"FStar.Sequence.Base.index",
"FStar.Sequence.Base.take_contains_equiv_exists_helper3",
"Prims.squash",
"Prims.l_True",
"FStar.Sequence.Base.take_contains_equiv_exists_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
| introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty) . contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (take_contains_equiv_exists_helper3 ty s n x) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_after_append_lemma | val index_after_append_lemma: squash (append_sums_lengths_fact u#a)
-> Lemma (index_after_append_fact u#a ()) | val index_after_append_lemma: squash (append_sums_lengths_fact u#a)
-> Lemma (index_after_append_fact u#a ()) | let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 207,
"start_col": 8,
"start_line": 200
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.squash FStar.Sequence.Base.append_sums_lengths_fact
-> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.index_after_append_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.squash",
"FStar.Sequence.Base.append_sums_lengths_fact",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.append",
"Prims.l_and",
"Prims.l_imp",
"Prims.eq2",
"FStar.Sequence.Base.index",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"FStar.Sequence.Base.index_after_append_helper",
"Prims.unit",
"Prims.l_True",
"FStar.Sequence.Base.index_after_append_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a))
: Lemma (index_after_append_fact u#a ()) =
| introduce forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}) . (n <
length s0 ==>
index (append s0 s1) n == index s0 n) /\
(length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (index_after_append_helper ty s0 s1 n) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.build_increments_length_lemma | val build_increments_length_lemma: Prims.unit -> Lemma (build_increments_length_fact) | val build_increments_length_lemma: Prims.unit -> Lemma (build_increments_length_fact) | let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 163,
"start_col": 8,
"start_line": 159
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
() | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.build_increments_length_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.build",
"Prims.op_Addition",
"FStar.List.Tot.Properties.append_length",
"Prims.Cons",
"Prims.Nil",
"Prims.squash",
"Prims.l_True",
"FStar.Sequence.Base.build_increments_length_fact",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
| introduce forall (ty: Type) (s: seq ty) (v: ty) . length (build s v) = 1 + length s
with (FLT.append_length s [v]) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.lemma_splitAt_fst_length | val lemma_splitAt_fst_length (#a: Type) (n: nat) (l: list a)
: Lemma (requires (n <= length l)) (ensures (length (fst (FLT.splitAt n l)) = n)) | val lemma_splitAt_fst_length (#a: Type) (n: nat) (l: list a)
: Lemma (requires (n <= length l)) (ensures (length (fst (FLT.splitAt n l)) = n)) | let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l' | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 216,
"start_col": 8,
"start_line": 209
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> l: Prims.list a
-> FStar.Pervasives.Lemma (requires n <= FStar.Sequence.Base.length l)
(ensures
FStar.Sequence.Base.length (FStar.Pervasives.Native.fst (FStar.List.Tot.Base.splitAt n l)) =
n) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"Prims.int",
"FStar.Sequence.Base.lemma_splitAt_fst_length",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.squash",
"Prims.op_Equality",
"FStar.Pervasives.Native.fst",
"FStar.List.Tot.Base.splitAt",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_splitAt_fst_length (#a: Type) (n: nat) (l: list a)
: Lemma (requires (n <= length l)) (ensures (length (fst (FLT.splitAt n l)) = n)) =
| match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l' | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.build_contains_equiv_helper | val build_contains_equiv_helper (ty: Type) (s: list ty) (v x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) | val build_contains_equiv_helper (ty: Type) (s: list ty) (v x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) | let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 49,
"end_line": 288,
"start_col": 8,
"start_line": 280
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
() | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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 | ty: Type -> s: Prims.list ty -> v: ty -> x: ty
-> FStar.Pervasives.Lemma
(ensures
FStar.List.Tot.Base.memP x (FStar.Sequence.Base.append s [v]) <==>
v == x \/ FStar.List.Tot.Base.memP x s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.Classical.Sugar.or_elim",
"Prims.eq2",
"Prims.squash",
"Prims.l_not",
"Prims.l_iff",
"FStar.List.Tot.Base.memP",
"FStar.Sequence.Base.append",
"Prims.Cons",
"Prims.Nil",
"Prims.l_or",
"FStar.Sequence.Base.build_contains_equiv_helper",
"Prims.unit",
"Prims.l_True",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
| match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _ . ()
and _ . build_contains_equiv_helper ty tl v x | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_contains_equiv_exists_helper2 | val take_contains_equiv_exists_helper2
(ty: Type)
(s: list ty)
(n: nat{n <= length s})
(x: ty)
(i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x)) (ensures FLT.memP x (take s n)) | val take_contains_equiv_exists_helper2
(ty: Type)
(s: list ty)
(n: nat{n <= length s})
(x: ty)
(i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x)) (ensures FLT.memP x (take s n)) | let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 81,
"end_line": 324,
"start_col": 8,
"start_line": 316
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ()) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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 |
ty: Type ->
s: Prims.list ty ->
n: Prims.nat{n <= FStar.Sequence.Base.length s} ->
x: ty ->
i: Prims.nat
-> FStar.Pervasives.Lemma
(requires i < n /\ i < FStar.Sequence.Base.length s /\ FStar.Sequence.Base.index s i == x)
(ensures FStar.List.Tot.Base.memP x (FStar.Sequence.Base.take s n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"FStar.Classical.Sugar.or_elim",
"Prims.eq2",
"Prims.squash",
"Prims.l_not",
"FStar.List.Tot.Base.memP",
"FStar.Sequence.Base.take",
"FStar.Sequence.Base.take_contains_equiv_exists_helper2",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_and",
"Prims.op_LessThan",
"FStar.Sequence.Base.index",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec take_contains_equiv_exists_helper2
(ty: Type)
(s: list ty)
(n: nat{n <= length s})
(x: ty)
(i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x)) (ensures FLT.memP x (take s n)) =
| match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd . ()
and case_x_ne_hd . take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_length_lemma | val drop_length_lemma: Prims.unit -> Lemma (drop_length_fact) | val drop_length_lemma: Prims.unit -> Lemma (drop_length_fact) | let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 468,
"start_col": 8,
"start_line": 461
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.drop_length_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.op_Equality",
"Prims.int",
"FStar.Sequence.Base.drop",
"Prims.op_Subtraction",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.List.Tot.Base.lemma_splitAt_snd_length",
"Prims.l_True",
"FStar.Sequence.Base.drop_length_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let drop_length_lemma () : Lemma (drop_length_fact) =
| introduce forall (ty: Type) (s: seq ty) (n: nat) . n <= length s ==>
length (drop s n) = length s - n
with introduce _ ==> _
with given_antecedent. (FLT.lemma_splitAt_snd_length n s) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.update_then_index_lemma | val update_then_index_lemma: Prims.unit -> Lemma (update_then_index_fact) | val update_then_index_lemma: Prims.unit -> Lemma (update_then_index_fact) | let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 257,
"start_col": 8,
"start_line": 246
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.update_then_index_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.update",
"Prims.l_imp",
"Prims.l_and",
"Prims.op_Equality",
"Prims.l_or",
"Prims.eq2",
"FStar.Sequence.Base.index",
"Prims.op_disEquality",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.Sequence.Base.update_then_index_helper",
"FStar.Sequence.Base.update_maintains_length_lemma",
"Prims.l_True",
"FStar.Sequence.Base.update_then_index_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let update_then_index_lemma () : Lemma (update_then_index_fact) =
| update_maintains_length_lemma ();
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n:
nat{n < length (update s i v)}) . n < length s ==>
(i = n ==> index (update s i v) n == v) /\ (i <> n ==> index (update s i v) n == index s n)
with introduce _ ==> _
with given_antecedent. (update_then_index_helper s i v n) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_length_lemma | val take_length_lemma: Prims.unit -> Lemma (take_length_fact) | val take_length_lemma: Prims.unit -> Lemma (take_length_fact) | let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 441,
"start_col": 8,
"start_line": 434
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
() | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.take_length_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.op_Equality",
"FStar.Sequence.Base.take",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.Sequence.Base.lemma_splitAt_fst_length",
"Prims.l_True",
"FStar.Sequence.Base.take_length_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let take_length_lemma () : Lemma (take_length_fact) =
| introduce forall (ty: Type) (s: seq ty) (n: nat) . n <= length s ==> length (take s n) = n
with introduce _ ==> _
with given_antecedent. (lemma_splitAt_fst_length n s) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_contains_equiv_exists_lemma | val drop_contains_equiv_exists_lemma: Prims.unit -> Lemma (drop_contains_equiv_exists_fact) | val drop_contains_equiv_exists_lemma: Prims.unit -> Lemma (drop_contains_equiv_exists_fact) | let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 412,
"start_col": 8,
"start_line": 403
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.drop_contains_equiv_exists_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.l_iff",
"FStar.Sequence.Base.contains",
"FStar.Sequence.Base.drop",
"Prims.l_Exists",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.eq2",
"FStar.Sequence.Base.index",
"Prims._assert",
"FStar.List.Tot.Base.memP",
"FStar.Sequence.Base.drop_contains_equiv_exists_helper3",
"Prims.squash",
"Prims.l_True",
"FStar.Sequence.Base.drop_contains_equiv_exists_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
| introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty) . contains (drop s n) x <==>
(exists (i: nat). {:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==> (exists (i: nat). n <= i /\ i < length s /\ index s i == x))) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_left_mul_identity_aux_3 | val matrix_left_mul_identity_aux_3
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1) {k > i + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_mul_unit add mul m) i k) `mul.mult` (ijth mx k j)))
)
`eq.eq`
(ijth mx i j)) | val matrix_left_mul_identity_aux_3
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: under (m + 1) {k > i + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_mul_unit add mul m) i k) `mul.mult` (ijth mx k j)))
)
`eq.eq`
(ijth mx i j)) | let rec matrix_left_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under(m+1){k>i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
if (k-1 = i+1) then matrix_left_mul_identity_aux_2 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_3 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 1014,
"start_col": 0,
"start_line": 982
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit
let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_right_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1){k>j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j)
(decreases k) =
if (k-1) > j+1 then matrix_right_mul_identity_aux_3 add mul mx i j (k-1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k-1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let subgen (i: under (k)) = gen i in
let full = SB.init k gen in
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_right_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq`
(if k>j then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else if k <= j then matrix_right_mul_identity_aux_1 add mul mx i j k
else if k = j+1 then matrix_right_mul_identity_aux_2 add mul mx i j k
else matrix_right_mul_identity_aux_3 add mul mx i j k
let matrix_left_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) = eq.reflexivity add.unit
let rec matrix_left_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=i /\ k>0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
if k=1 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
SP.foldm_snoc_decomposition add full;
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
#push-options "--z3rlimit 20"
let matrix_left_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
assert (k-1 <= i /\ k-1 >= 0);
if (k-1)=0 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: FStar.IntegerIntervals.under (m + 1) {k > i + 1}
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc add
(FStar.Seq.Base.init k
(fun k ->
CM?.mult mul
(FStar.Matrix.ijth (FStar.Matrix.matrix_mul_unit add mul m) i k)
(FStar.Matrix.ijth mx k j))))
(FStar.Matrix.ijth mx i j)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.op_Addition",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.seq",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Seq.Base.init",
"Prims.op_Subtraction",
"FStar.Matrix.ijth",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__identity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__commutativity",
"FStar.Seq.Base.lemma_eq_elim",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc",
"FStar.Matrix.liat_equals_init",
"FStar.Seq.Permutation.foldm_snoc_decomposition",
"FStar.Matrix.matrix_mul_unit_ijth",
"Prims.op_Equality",
"Prims.int",
"FStar.Matrix.matrix_left_mul_identity_aux_2",
"Prims.bool",
"FStar.Matrix.matrix_left_mul_identity_aux_3",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.matrix_mul",
"FStar.Matrix.matrix_mul_unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec matrix_left_mul_identity_aux_3
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: under (m + 1) {k > i + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth (matrix_mul_unit add mul m) i k) `mul.mult` (ijth mx k j)))
)
`eq.eq`
(ijth mx i j)) =
| let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
if (k - 1 = i + 1)
then matrix_left_mul_identity_aux_2 add mul mx i j (k - 1)
else matrix_left_mul_identity_aux_3 add mul mx i j (k - 1);
matrix_mul_unit_ijth add mul m i (k - 1);
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat, last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k - 1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k - 1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k - 1) gen));
add.congruence last
(SP.foldm_snoc add (SB.init (k - 1) gen))
add.unit
(SP.foldm_snoc add (SB.init (k - 1) gen));
add.identity (SP.foldm_snoc add (SB.init (k - 1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k - 1) gen)))
(SP.foldm_snoc add (SB.init (k - 1) gen));
eq.transitivity (SP.foldm_snoc add full) (SP.foldm_snoc add (SB.init (k - 1) gen)) (ijth mx i j) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_into_build_lemma | val index_into_build_lemma: Prims.unit
-> Lemma (requires build_increments_length_fact u#a) (ensures index_into_build_fact u#a ()) | val index_into_build_lemma: Prims.unit
-> Lemma (requires build_increments_length_fact u#a) (ensures index_into_build_fact u#a ()) | let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 182,
"start_col": 8,
"start_line": 174
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma (requires FStar.Sequence.Base.build_increments_length_fact)
(ensures FStar.Sequence.Base.index_into_build_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.build",
"Prims.l_and",
"Prims.l_imp",
"Prims.op_Equality",
"Prims.eq2",
"FStar.Sequence.Base.index",
"Prims.op_disEquality",
"FStar.Sequence.Base.index_into_build_helper",
"Prims.squash",
"FStar.Sequence.Base.build_increments_length_fact",
"FStar.Sequence.Base.index_into_build_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a) (ensures index_into_build_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}) . (i = length s ==>
index (build s v) i == v) /\ (i <> length s ==> index (build s v) i == index s i)
with (index_into_build_helper u#a s v i) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_contains_equiv_exists_helper1 | val take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x)) | val take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x)) | let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ()) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 15,
"end_line": 314,
"start_col": 8,
"start_line": 298
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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 | ty: Type -> s: Prims.list ty -> n: Prims.nat{n <= FStar.Sequence.Base.length s} -> x: ty
-> FStar.Pervasives.Lemma (requires FStar.List.Tot.Base.memP x (FStar.Sequence.Base.take s n))
(ensures
exists (i: Prims.nat). {:pattern FStar.Sequence.Base.index s i}
i < n /\ i < FStar.Sequence.Base.length s /\ FStar.Sequence.Base.index s i == x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"FStar.Classical.Sugar.or_elim",
"Prims.eq2",
"Prims.squash",
"Prims.l_not",
"Prims.l_Exists",
"Prims.l_and",
"Prims.op_LessThan",
"FStar.Sequence.Base.index",
"Prims._assert",
"FStar.Classical.Sugar.exists_elim",
"Prims.op_Subtraction",
"FStar.Classical.Sugar.exists_intro",
"Prims.op_Addition",
"Prims.unit",
"FStar.Sequence.Base.take_contains_equiv_exists_helper1",
"FStar.List.Tot.Base.memP",
"FStar.Sequence.Base.take",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
| match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd . assert (index s 0 == x)
and case_x_ne_hd . (take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat).
i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat).i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ()) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.update_maintains_length_helper | val update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) | val update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) | let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 224,
"start_col": 8,
"start_line": 218
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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: Prims.list ty -> i: Prims.nat{i < FStar.Sequence.Base.length s} -> v: ty
-> FStar.Pervasives.Lemma
(ensures
FStar.Sequence.Base.length (FStar.Sequence.Base.update s i v) = FStar.Sequence.Base.length s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.List.Tot.Properties.append_length",
"FStar.Sequence.Base.append",
"Prims.Cons",
"Prims.Nil",
"Prims.unit",
"FStar.List.Tot.Base.lemma_splitAt_snd_length",
"FStar.Sequence.Base.lemma_splitAt_fst_length",
"FStar.Pervasives.Native.tuple3",
"FStar.List.Tot.Base.split3",
"Prims.l_True",
"Prims.squash",
"Prims.op_Equality",
"FStar.Sequence.Base.update",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
| let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_contains_equiv_exists_helper3 | val take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma
(FLT.memP x (take s n) <==>
(exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x)) | val take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma
(FLT.memP x (take s n) <==>
(exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x)) | let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 338,
"start_col": 8,
"start_line": 326
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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 | ty: Type -> s: Prims.list ty -> n: Prims.nat{n <= FStar.Sequence.Base.length s} -> x: ty
-> FStar.Pervasives.Lemma
(ensures
FStar.List.Tot.Base.memP x (FStar.Sequence.Base.take s n) <==>
(exists (i: Prims.nat). {:pattern FStar.Sequence.Base.index s i}
i < n /\ i < FStar.Sequence.Base.length s /\ FStar.Sequence.Base.index s i == x)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"FStar.Classical.Sugar.implies_intro",
"Prims.l_Exists",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.eq2",
"FStar.Sequence.Base.index",
"Prims.squash",
"FStar.List.Tot.Base.memP",
"FStar.Sequence.Base.take",
"FStar.Classical.Sugar.exists_elim",
"FStar.Sequence.Base.take_contains_equiv_exists_helper2",
"Prims.unit",
"FStar.Sequence.Base.take_contains_equiv_exists_helper1",
"Prims.l_True",
"Prims.l_iff",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma
(FLT.memP x (take s n) <==>
(exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
| introduce FLT.memP x (take s n) ==> (exists (i: nat). {:pattern index s i}
i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat). {:pattern index s i} i < n /\ i < length s /\ index s i == x) ==> FLT.memP
x
(take s n)
with given_antecedent. (eliminate exists (i: nat).
i < n /\ i < length s /\ index s i == x
returns _
with _.
take_contains_equiv_exists_helper2 ty s n x i) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_contains_equiv_exists_helper2 | val drop_contains_equiv_exists_helper2
(ty: Type)
(s: list ty)
(n: nat{n <= length s})
(x: ty)
(i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x)) (ensures FLT.memP x (drop s n)) | val drop_contains_equiv_exists_helper2
(ty: Type)
(s: list ty)
(n: nat{n <= length s})
(x: ty)
(i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x)) (ensures FLT.memP x (drop s n)) | let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 93,
"end_line": 386,
"start_col": 8,
"start_line": 373
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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 |
ty: Type ->
s: Prims.list ty ->
n: Prims.nat{n <= FStar.Sequence.Base.length s} ->
x: ty ->
i: Prims.nat
-> FStar.Pervasives.Lemma
(requires n <= i /\ i < FStar.Sequence.Base.length s /\ FStar.Sequence.Base.index s i == x)
(ensures FStar.List.Tot.Base.memP x (FStar.Sequence.Base.drop s n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"FStar.Classical.Sugar.or_elim",
"Prims.eq2",
"Prims.int",
"Prims.squash",
"Prims.l_not",
"Prims.op_disEquality",
"FStar.List.Tot.Base.memP",
"FStar.Sequence.Base.drop",
"FStar.List.Tot.Properties.lemma_index_memP",
"FStar.Classical.Sugar.exists_elim",
"Prims.l_and",
"Prims.op_Subtraction",
"Prims.op_LessThan",
"FStar.Sequence.Base.index",
"Prims.l_Exists",
"Prims.op_GreaterThanOrEqual",
"FStar.Classical.Sugar.exists_intro",
"Prims.op_Addition",
"Prims.unit",
"FStar.Sequence.Base.drop_contains_equiv_exists_helper2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec drop_contains_equiv_exists_helper2
(ty: Type)
(s: list ty)
(n: nat{n <= length s})
(x: ty)
(i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x)) (ensures FLT.memP x (drop s n)) =
| match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _ . FLT.lemma_index_memP s i
and _ . (drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat).
n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i.n <= i /\ i < length s /\ index s i == x
with (i_tl + 1)
and ()) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.contains_iff_exists_index_lemma | val contains_iff_exists_index_lemma: Prims.unit -> Lemma (contains_iff_exists_index_fact) | val contains_iff_exists_index_lemma: Prims.unit -> Lemma (contains_iff_exists_index_fact) | let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 275,
"start_col": 8,
"start_line": 259
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.contains_iff_exists_index_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.l_iff",
"FStar.Sequence.Base.contains",
"Prims.l_Exists",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.index",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.Classical.Sugar.exists_elim",
"FStar.List.Tot.Properties.lemma_index_memP",
"FStar.Classical.Sugar.exists_intro",
"FStar.List.Tot.Properties.index_of",
"Prims.l_True",
"FStar.Sequence.Base.contains_iff_exists_index_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
| introduce forall (ty: Type) (s: seq ty) (x: ty) . contains s x <==>
(exists (i: nat). {:pattern index s i} i < length s /\ index s i == x)
with (introduce contains s x ==> (exists (i: nat). {:pattern index s i}
i < length s /\ index s i == x)
with given_antecedent. (introduce exists (i: nat).i < length s /\ index s i == x
with (FLT.index_of s x)
and ());
introduce (exists (i: nat). {:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (eliminate exists (i: nat).
i < length s /\ index s i == x
returns _
with _.
FLT.lemma_index_memP s i)) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_is_associative | val matrix_mul_is_associative (#c:_) (#eq:_) (#m #n #p #q: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma ((matrix_equiv eq m q).eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) | val matrix_mul_is_associative (#c:_) (#eq:_) (#m #n #p #q: pos) (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma ((matrix_equiv eq m q).eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) | let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 46,
"end_line": 718,
"start_col": 0,
"start_line": 663
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 15,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul:
FStar.Algebra.CommMonoid.Equiv.cm c eq
{FStar.Matrix.is_fully_distributive mul add /\ FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m n ->
my: FStar.Matrix.matrix c n p ->
mz: FStar.Matrix.matrix c p q
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq (FStar.Matrix.matrix_equiv eq m q)
(FStar.Matrix.matrix_mul add mul (FStar.Matrix.matrix_mul add mul mx my) mz)
(FStar.Matrix.matrix_mul add mul mx (FStar.Matrix.matrix_mul add mul my mz))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"Prims.l_and",
"FStar.Matrix.is_fully_distributive",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_proof",
"FStar.IntegerIntervals.under",
"Prims.squash",
"FStar.Matrix.ijth",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__symmetry",
"FStar.Seq.Permutation.foldm_snoc_of_equal_inits",
"FStar.Classical.forall_intro",
"Prims.l_True",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Matrix.foldm_snoc_distributivity_left_eq",
"FStar.Seq.Base.init",
"FStar.Matrix.matrix_mul_ijth_eq_sum_of_seq_for_init",
"Prims.eq2",
"FStar.Matrix.double_foldm_snoc_of_equal_generators",
"FStar.Classical.forall_intro_2",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__associativity",
"FStar.Matrix.double_foldm_snoc_transpose_lemma",
"FStar.Matrix.foldm_snoc_distributivity_right_eq",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.Mktuple3",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.matrix_mul",
"FStar.Matrix.matrix_eq_fun"
] | [] | false | false | true | false | false | let matrix_mul_is_associative
#c
#eq
#m
#n
#p
#q
(add: CE.cm c eq)
(mul: CE.cm c eq {is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n)
(my: matrix c n p)
(mz: matrix c p q)
: Lemma
(matrix_eq_fun eq
(matrix_mul add mul (matrix_mul add mul mx my) mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
| let rhs = matrix_mul add mul mx (matrix_mul add mul my mz) in
let lhs = matrix_mul add mul (matrix_mul add mul mx my) mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ( + ), ( * ), ( = ) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: (under n -> c)) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: (under p -> c)) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in
Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k)) =
foldm_snoc_distributivity_right_eq mul
add
(SB.init n (xy_products_init k))
(ijth mz k l)
(SB.init n (full_init_kj k))
in
Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init (fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj) (sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k) =
mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in
Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
()
in
Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j)) =
foldm_snoc_distributivity_left_eq mul
add
(ijth mx i j)
(SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in
Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
()
in
matrix_equiv_from_proof eq lhs rhs aux | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.extensionality_lemma | val extensionality_lemma: Prims.unit -> Lemma (extensionality_fact) | val extensionality_lemma: Prims.unit -> Lemma (extensionality_fact) | let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 429,
"start_col": 8,
"start_line": 417
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
() | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.extensionality_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.l_imp",
"FStar.Sequence.Base.equal",
"Prims.eq2",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.List.Tot.Properties.index_extensionality",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.index",
"Prims._assert",
"Prims.l_True",
"FStar.Sequence.Base.extensionality_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let extensionality_lemma () : Lemma (extensionality_fact) =
| introduce forall (ty: Type) (a: seq ty) (b: seq ty) . equal a b ==> a == b
with introduce _ ==> _
with given_antecedent. (introduce forall (i: nat) . i < length a ==> index a i == index b i
with introduce _ ==> _
with given_antecedent. (assert (index a i == index b i));
FStar.List.Tot.Properties.index_extensionality a b) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_contains_equiv_exists_helper3 | val drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma
(FLT.memP x (drop s n) <==>
(exists (i: nat). {:pattern index s i} n <= i /\ i < length s /\ index s i == x)) | val drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma
(FLT.memP x (drop s n) <==>
(exists (i: nat). {:pattern index s i} n <= i /\ i < length s /\ index s i == x)) | let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 401,
"start_col": 8,
"start_line": 388
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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 | ty: Type -> s: Prims.list ty -> n: Prims.nat{n <= FStar.Sequence.Base.length s} -> x: ty
-> FStar.Pervasives.Lemma
(ensures
FStar.List.Tot.Base.memP x (FStar.Sequence.Base.drop s n) <==>
(exists (i: Prims.nat). {:pattern FStar.Sequence.Base.index s i}
n <= i /\ i < FStar.Sequence.Base.length s /\ FStar.Sequence.Base.index s i == x)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"FStar.Classical.Sugar.implies_intro",
"Prims.l_Exists",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.eq2",
"FStar.Sequence.Base.index",
"Prims.squash",
"FStar.List.Tot.Base.memP",
"FStar.Sequence.Base.drop",
"FStar.Classical.Sugar.exists_elim",
"FStar.Sequence.Base.drop_contains_equiv_exists_helper2",
"Prims.unit",
"FStar.Sequence.Base.drop_contains_equiv_exists_helper1",
"Prims.l_True",
"Prims.l_iff",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma
(FLT.memP x (drop s n) <==>
(exists (i: nat). {:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
| introduce FLT.memP x (drop s n) ==> (exists (i: nat). {:pattern index s i}
n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat). {:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==> FLT.memP
x
(drop s n)
with given_antecedent. (eliminate exists (i: nat).
n <= i /\ i < length s /\ index s i == x
returns _
with _.
drop_contains_equiv_exists_helper2 ty s n x i) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_into_take_lemma | val index_into_take_lemma: Prims.unit
-> Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) | val index_into_take_lemma: Prims.unit
-> Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) | let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 459,
"start_col": 8,
"start_line": 449
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma (requires FStar.Sequence.Base.take_length_fact)
(ensures FStar.Sequence.Base.index_into_take_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.index",
"FStar.Sequence.Base.take",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.Sequence.Base.index_into_take_helper",
"Prims._assert",
"FStar.Sequence.Base.take_length_fact",
"FStar.Sequence.Base.index_into_take_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (n: nat) (j: nat) . j < n && n <= length s ==>
index (take s n) j == index s j
with introduce _ ==> _
with given_antecedent. (assert (length (take s n) == n);
index_into_take_helper s n j) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_into_build_helper | val index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) | val index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) | let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 64,
"end_line": 172,
"start_col": 8,
"start_line": 165
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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: Prims.list ty ->
v: ty ->
i: Prims.nat{i < FStar.Sequence.Base.length (FStar.Sequence.Base.append s [v])}
-> FStar.Pervasives.Lemma (requires i <= FStar.Sequence.Base.length s)
(ensures
FStar.Sequence.Base.index (FStar.Sequence.Base.append s [v]) i ==
(match i = FStar.Sequence.Base.length s with
| true -> v
| _ -> FStar.Sequence.Base.index s i)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.append",
"Prims.Cons",
"Prims.Nil",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Sequence.Base.index_into_build_helper",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.List.Tot.Properties.append_length",
"Prims.op_LessThanOrEqual",
"Prims.squash",
"Prims.eq2",
"FStar.Sequence.Base.index",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
| FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl -> if i = 0 then () else index_into_build_helper tl v (i - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_into_take_helper | val index_into_take_helper (#ty: Type) (s: list ty) (n j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) | val index_into_take_helper (#ty: Type) (s: list ty) (n j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) | let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 88,
"end_line": 447,
"start_col": 8,
"start_line": 443
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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: Prims.list ty -> n: Prims.nat -> j: Prims.nat
-> FStar.Pervasives.Lemma
(requires
j < n && n <= FStar.Sequence.Base.length s /\
FStar.Sequence.Base.length (FStar.Sequence.Base.take s n) = n)
(ensures
FStar.Sequence.Base.index (FStar.Sequence.Base.take s n) j == FStar.Sequence.Base.index s j) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.op_BarBar",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Sequence.Base.index_into_take_helper",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.take",
"Prims.squash",
"Prims.eq2",
"FStar.Sequence.Base.index",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec index_into_take_helper (#ty: Type) (s: list ty) (n j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
| match s with | hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_after_append_helper | val index_after_append_helper (ty: Type) (s0 s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures
index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) | val index_after_append_helper (ty: Type) (s0 s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures
index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) | let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 80,
"end_line": 198,
"start_col": 8,
"start_line": 193
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
() | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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 | ty: Type -> s0: Prims.list ty -> s1: Prims.list ty -> n: Prims.nat
-> FStar.Pervasives.Lemma
(requires
n < FStar.Sequence.Base.length (FStar.Sequence.Base.append s0 s1) &&
FStar.Sequence.Base.length (FStar.Sequence.Base.append s0 s1) =
FStar.Sequence.Base.length s0 + FStar.Sequence.Base.length s1)
(ensures
FStar.Sequence.Base.index (FStar.Sequence.Base.append s0 s1) n ==
(match n < FStar.Sequence.Base.length s0 with
| true -> FStar.Sequence.Base.index s0 n
| _ -> FStar.Sequence.Base.index s1 (n - FStar.Sequence.Base.length s0))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Sequence.Base.index_after_append_helper",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.append",
"Prims.op_Addition",
"Prims.squash",
"Prims.eq2",
"FStar.Sequence.Base.index",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec index_after_append_helper (ty: Type) (s0 s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures
index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
| match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.element_ranks_less_lemma | val element_ranks_less_lemma: Prims.unit -> Lemma (element_ranks_less_fact) | val element_ranks_less_lemma: Prims.unit -> Lemma (element_ranks_less_fact) | let element_ranks_less_lemma () : Lemma (element_ranks_less_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat). i < length s ==> rank (index s i) << rank s
with
introduce _ ==> _
with given_antecedent. (
contains_iff_exists_index_lemma ();
assert (contains s (index s i));
FLT.memP_precedes (index s i) s
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 656,
"start_col": 8,
"start_line": 648
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1)
private let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
)
#push-options "--z3rlimit 20"
private let rec take_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s
/\ length (take s n) = n)
(ensures take (update s i v) n == update (take s n) i v) =
match s with
| hd :: tl -> if i = 0 then () else (update_maintains_length_lemma() ; take_commutes_with_in_range_update_helper tl (i - 1) v (n - 1))
#pop-options
private let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (take s n) = n); // triggers take_length_fact
take_commutes_with_in_range_update_helper s i v n
)
private let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
take (update s i v) n == take s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
take_ignores_out_of_range_update_helper s i v n
)
#push-options "--fuel 2 --ifuel 1 --z3rlimit_factor 4"
private let rec drop_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s
/\ length (drop s n) = length s - n)
(ensures drop (update s i v) n ==
update (drop s n) (i - n) v) =
match s with
| hd :: tl ->
if n = 0
then ()
else (
update_maintains_length_lemma ();
drop_length_lemma ();
drop_commutes_with_in_range_update_helper tl (i - 1) v (n - 1)
)
#pop-options
private let drop_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
drop (update s i v) n == update (drop s n) (i - n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (drop s n) = length s - n); // triggers drop_length_fact
drop_commutes_with_in_range_update_helper s i v n
)
private let rec drop_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s)
(ensures drop (update s i v) n == drop s n) =
match s with
| hd :: tl -> if i = 0 then () else drop_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let drop_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
drop (update s i v) n == drop s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
drop_ignores_out_of_range_update_helper s i v n
)
private let rec drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) =
match s with
| [] ->
assert (append s [v] == [v]);
assert (n == 0);
()
| hd :: tl -> if n = 0 then () else drop_commutes_with_build_helper tl v (n - 1)
private let drop_commutes_with_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (n: nat).
n <= length s ==> drop (build s v) n == build (drop s n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (build s v) = 1 + length s); // triggers build_increments_length_fact
drop_commutes_with_build_helper s v n
)
private let rank_def_lemma () : Lemma (rank_def_fact) =
() | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.element_ranks_less_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.precedes",
"FStar.Sequence.Base.rank",
"FStar.Sequence.Base.index",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.List.Tot.Properties.memP_precedes",
"Prims._assert",
"FStar.Sequence.Base.contains",
"FStar.Sequence.Base.contains_iff_exists_index_lemma",
"Prims.l_True",
"FStar.Sequence.Base.element_ranks_less_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let element_ranks_less_lemma () : Lemma (element_ranks_less_fact) =
| introduce forall (ty: Type) (s: seq ty) (i: nat) . i < length s ==> rank (index s i) << rank s
with introduce _ ==> _
with given_antecedent. (contains_iff_exists_index_lemma ();
assert (contains s (index s i));
FLT.memP_precedes (index s i) s) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.index_into_drop_lemma | val index_into_drop_lemma: Prims.unit
-> Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) | val index_into_drop_lemma: Prims.unit
-> Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) | let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 486,
"start_col": 8,
"start_line": 476
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma (requires FStar.Sequence.Base.drop_length_fact)
(ensures FStar.Sequence.Base.index_into_drop_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Subtraction",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.index",
"FStar.Sequence.Base.drop",
"Prims.op_Addition",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.Sequence.Base.index_into_drop_helper",
"Prims._assert",
"Prims.op_Equality",
"Prims.int",
"FStar.Sequence.Base.drop_length_fact",
"FStar.Sequence.Base.index_into_drop_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (n: nat) (j: nat) . j < length s - n ==>
index (drop s n) j == index s (j + n)
with introduce _ ==> _
with given_antecedent. (assert (length (drop s n) = length s - n);
index_into_drop_helper s n j) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.append_then_take_or_drop_lemma | val append_then_take_or_drop_lemma: Prims.unit
-> Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) | val append_then_take_or_drop_lemma: Prims.unit
-> Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) | let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 516,
"start_col": 8,
"start_line": 507
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma (requires FStar.Sequence.Base.append_sums_lengths_fact)
(ensures FStar.Sequence.Base.append_then_take_or_drop_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Sequence.Base.length",
"Prims.l_and",
"Prims.eq2",
"FStar.Sequence.Base.take",
"FStar.Sequence.Base.append",
"FStar.Sequence.Base.drop",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.Sequence.Base.append_then_take_or_drop_helper",
"FStar.Sequence.Base.append_sums_lengths_fact",
"FStar.Sequence.Base.append_then_take_or_drop_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat) . n = length s ==>
take (append s t) n == s /\ drop (append s t) n == t
with introduce _ ==> _
with given_antecedent. (append_then_take_or_drop_helper s t n) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_commutes_with_build_lemma | val drop_commutes_with_build_lemma: Prims.unit
-> Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) | val drop_commutes_with_build_lemma: Prims.unit
-> Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) | let drop_commutes_with_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (n: nat).
n <= length s ==> drop (build s v) n == build (drop s n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (build s v) = 1 + length s); // triggers build_increments_length_fact
drop_commutes_with_build_helper s v n
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 643,
"start_col": 8,
"start_line": 632
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1)
private let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
)
#push-options "--z3rlimit 20"
private let rec take_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s
/\ length (take s n) = n)
(ensures take (update s i v) n == update (take s n) i v) =
match s with
| hd :: tl -> if i = 0 then () else (update_maintains_length_lemma() ; take_commutes_with_in_range_update_helper tl (i - 1) v (n - 1))
#pop-options
private let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (take s n) = n); // triggers take_length_fact
take_commutes_with_in_range_update_helper s i v n
)
private let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
take (update s i v) n == take s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
take_ignores_out_of_range_update_helper s i v n
)
#push-options "--fuel 2 --ifuel 1 --z3rlimit_factor 4"
private let rec drop_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s
/\ length (drop s n) = length s - n)
(ensures drop (update s i v) n ==
update (drop s n) (i - n) v) =
match s with
| hd :: tl ->
if n = 0
then ()
else (
update_maintains_length_lemma ();
drop_length_lemma ();
drop_commutes_with_in_range_update_helper tl (i - 1) v (n - 1)
)
#pop-options
private let drop_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
drop (update s i v) n == update (drop s n) (i - n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (drop s n) = length s - n); // triggers drop_length_fact
drop_commutes_with_in_range_update_helper s i v n
)
private let rec drop_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s)
(ensures drop (update s i v) n == drop s n) =
match s with
| hd :: tl -> if i = 0 then () else drop_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let drop_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
drop (update s i v) n == drop s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
drop_ignores_out_of_range_update_helper s i v n
)
private let rec drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) =
match s with
| [] ->
assert (append s [v] == [v]);
assert (n == 0);
()
| hd :: tl -> if n = 0 then () else drop_commutes_with_build_helper tl v (n - 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma (requires FStar.Sequence.Base.build_increments_length_fact)
(ensures FStar.Sequence.Base.drop_commutes_with_build_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.drop",
"FStar.Sequence.Base.build",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.Sequence.Base.drop_commutes_with_build_helper",
"Prims._assert",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Addition",
"FStar.Sequence.Base.build_increments_length_fact",
"FStar.Sequence.Base.drop_commutes_with_build_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let drop_commutes_with_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (v: ty) (n: nat) . n <= length s ==>
drop (build s v) n == build (drop s n) v
with introduce _ ==> _
with given_antecedent. (assert (length (build s v) = 1 + length s);
drop_commutes_with_build_helper s v n) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_mul_congruence | val matrix_mul_congruence (#c:_) (#eq:_) (#m #n #p:pos) (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(mz: matrix c m n) (mw: matrix c n p)
: Lemma (requires (matrix_equiv eq m n).eq mx mz /\ (matrix_equiv eq n p).eq my mw)
(ensures (matrix_equiv eq m p).eq (matrix_mul add mul mx my)
(matrix_mul add mul mz mw)) | val matrix_mul_congruence (#c:_) (#eq:_) (#m #n #p:pos) (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(mz: matrix c m n) (mw: matrix c n p)
: Lemma (requires (matrix_equiv eq m n).eq mx mz /\ (matrix_equiv eq n p).eq my mw)
(ensures (matrix_equiv eq m p).eq (matrix_mul add mul mx my)
(matrix_mul add mul mz mw)) | let matrix_mul_congruence #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(mz: matrix c m n) (mw: matrix c n p)
: Lemma (requires matrix_eq_fun eq mx mz /\ matrix_eq_fun eq my mw)
(ensures matrix_eq_fun eq (matrix_mul add mul mx my) (matrix_mul add mul mz mw)) =
let aux (i: under m) (k: under p) : Lemma (ijth (matrix_mul add mul mx my) i k
`eq.eq` ijth (matrix_mul add mul mz mw) i k) =
let init_xy (j: under n) = mul.mult (ijth mx i j) (ijth my j k) in
let init_zw (j: under n) = mul.mult (ijth mz i j) (ijth mw j k) in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k init_xy;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mz mw i k init_zw;
let sp_xy = SB.init n init_xy in
let sp_zw = SB.init n init_zw in
let all_eq (j: under n) : Lemma (init_xy j `eq.eq` init_zw j) =
matrix_equiv_ijth eq mx mz i j;
matrix_equiv_ijth eq my mw j k;
mul.congruence (ijth mx i j) (ijth my j k) (ijth mz i j) (ijth mw j k)
in Classical.forall_intro all_eq;
eq_of_seq_from_element_equality eq sp_xy sp_zw;
SP.foldm_snoc_equality add sp_xy sp_zw
in matrix_equiv_from_proof eq (matrix_mul add mul mx my) (matrix_mul add mul mz mw) aux | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 89,
"end_line": 1103,
"start_col": 0,
"start_line": 1083
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit
let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_right_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1){k>j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j)
(decreases k) =
if (k-1) > j+1 then matrix_right_mul_identity_aux_3 add mul mx i j (k-1)
else matrix_right_mul_identity_aux_2 add mul mx i j (k-1);
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let subgen (i: under (k)) = gen i in
let full = SB.init k gen in
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_right_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth mx i k `mul.mult` ijth (matrix_mul_unit add mul m) k j))
`eq.eq`
(if k>j then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else if k <= j then matrix_right_mul_identity_aux_1 add mul mx i j k
else if k = j+1 then matrix_right_mul_identity_aux_2 add mul mx i j k
else matrix_right_mul_identity_aux_3 add mul mx i j k
let matrix_left_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) = eq.reflexivity add.unit
let rec matrix_left_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=i /\ k>0})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` add.unit) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
if k=1 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
SP.foldm_snoc_decomposition add full;
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit
#push-options "--z3rlimit 20"
let matrix_left_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
assert (k-1 <= i /\ k-1 >= 0);
if (k-1)=0 then matrix_left_mul_identity_aux_0 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_1 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j)
let rec matrix_left_mul_identity_aux_3 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under(m+1){k>i+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen (k: under m) = ijth unit i k * ijth mx k j in
let full = SB.init k gen in
if (k-1 = i+1) then matrix_left_mul_identity_aux_2 add mul mx i j (k-1)
else matrix_left_mul_identity_aux_3 add mul mx i j (k-1);
matrix_mul_unit_ijth add mul m i (k-1); // This one reduces the rlimits needs to default
SP.foldm_snoc_decomposition add full;
liat_equals_init k gen;
let liat,last = SProp.un_snoc full in
SB.lemma_eq_elim liat (SB.init (k-1) gen);
add.identity add.unit;
mul.commutativity (ijth mx i (k-1)) add.unit;
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
add.congruence last (SP.foldm_snoc add (SB.init (k-1) gen))
add.unit (SP.foldm_snoc add (SB.init (k-1) gen));
add.identity (SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit (SP.foldm_snoc add (SB.init (k-1) gen)))
(SP.foldm_snoc add (SB.init (k-1) gen));
eq.transitivity (SP.foldm_snoc add full)
(SP.foldm_snoc add (SB.init (k-1) gen))
(ijth mx i j)
let matrix_left_identity_aux #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:under (m+1))
: Lemma (ensures SP.foldm_snoc add (SB.init k
(fun (k: under m) -> ijth (matrix_mul_unit add mul m) i k `mul.mult` ijth mx k j))
`eq.eq` (if k>i then ijth mx i j else add.unit))
(decreases k) =
if k=0 then matrix_left_mul_identity_aux_0 add mul mx i j k
else if k <= i then matrix_left_mul_identity_aux_1 add mul mx i j k
else if k = i+1 then matrix_left_mul_identity_aux_2 add mul mx i j k
else matrix_left_mul_identity_aux_3 add mul mx i j k
let matrix_mul_right_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `matrix_eq_fun eq` mx) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : Lemma (ijth mxu i j $=$ ijth mx i j) =
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx unit i j gen;
let seq = SB.init m gen in
matrix_right_identity_aux add mul mx i j m
in Classical.forall_intro_2 aux;
matrix_equiv_from_element_eq eq mxu mx
let matrix_mul_left_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul (matrix_mul_unit add mul m) mx `matrix_eq_fun eq` mx) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul unit mx in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let aux (i j: under m) : squash (ijth mxu i j $=$ ijth mx i j) =
let gen (k: under m) = ijth unit i k * ijth mx k j in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul unit mx i j gen;
let seq = SB.init m gen in
matrix_left_identity_aux add mul mx i j m
in
matrix_equiv_from_proof eq mxu mx aux
let matrix_mul_identity #c #eq #m (add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
: Lemma (matrix_mul add mul mx (matrix_mul_unit add mul m) `matrix_eq_fun eq` mx /\
matrix_mul add mul (matrix_mul_unit add mul m) mx `matrix_eq_fun eq` mx) =
matrix_mul_left_identity add mul mx;
matrix_mul_right_identity add mul mx
let dot_of_equal_sequences #c #eq (add mul: CE.cm c eq) m
(p q r s: (z:SB.seq c{SB.length z == m}))
: Lemma (requires eq_of_seq eq p r /\ eq_of_seq eq q s)
(ensures eq.eq (dot add mul p q) (dot add mul r s)) =
eq_of_seq_element_equality eq p r;
eq_of_seq_element_equality eq q s;
let aux (i: under (SB.length p)) : Lemma (SB.index (seq_of_products mul p q) i `eq.eq`
SB.index (seq_of_products mul r s) i)
= mul.congruence (SB.index p i) (SB.index q i) (SB.index r i) (SB.index s i)
in Classical.forall_intro aux;
eq_of_seq_from_element_equality eq (seq_of_products mul p q) (seq_of_products mul r s);
SP.foldm_snoc_equality add (seq_of_products mul p q) (seq_of_products mul r s) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mx: FStar.Matrix.matrix c m n ->
my: FStar.Matrix.matrix c n p ->
mz: FStar.Matrix.matrix c m n ->
mw: FStar.Matrix.matrix c n p
-> FStar.Pervasives.Lemma
(requires
EQ?.eq (FStar.Matrix.matrix_equiv eq m n) mx mz /\
EQ?.eq (FStar.Matrix.matrix_equiv eq n p) my mw)
(ensures
EQ?.eq (FStar.Matrix.matrix_equiv eq m p)
(FStar.Matrix.matrix_mul add mul mx my)
(FStar.Matrix.matrix_mul add mul mz mw)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.matrix",
"FStar.Matrix.matrix_equiv_from_proof",
"FStar.Matrix.matrix_mul",
"FStar.IntegerIntervals.under",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.ijth",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Seq.Permutation.foldm_snoc_equality",
"FStar.Seq.Equiv.eq_of_seq_from_element_equality",
"FStar.Classical.forall_intro",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Matrix.matrix_equiv_ijth",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.init",
"FStar.Matrix.matrix_mul_ijth_eq_sum_of_seq_for_init",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"Prims.l_and",
"FStar.Matrix.matrix_eq_fun"
] | [] | false | false | true | false | false | let matrix_mul_congruence
#c
#eq
#m
#n
#p
(add: CE.cm c eq)
(mul: CE.cm c eq)
(mx: matrix c m n)
(my: matrix c n p)
(mz: matrix c m n)
(mw: matrix c n p)
: Lemma (requires matrix_eq_fun eq mx mz /\ matrix_eq_fun eq my mw)
(ensures matrix_eq_fun eq (matrix_mul add mul mx my) (matrix_mul add mul mz mw)) =
| let aux (i: under m) (k: under p)
: Lemma ((ijth (matrix_mul add mul mx my) i k) `eq.eq` (ijth (matrix_mul add mul mz mw) i k)) =
let init_xy (j: under n) = mul.mult (ijth mx i j) (ijth my j k) in
let init_zw (j: under n) = mul.mult (ijth mz i j) (ijth mw j k) in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k init_xy;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mz mw i k init_zw;
let sp_xy = SB.init n init_xy in
let sp_zw = SB.init n init_zw in
let all_eq (j: under n) : Lemma ((init_xy j) `eq.eq` (init_zw j)) =
matrix_equiv_ijth eq mx mz i j;
matrix_equiv_ijth eq my mw j k;
mul.congruence (ijth mx i j) (ijth my j k) (ijth mz i j) (ijth mw j k)
in
Classical.forall_intro all_eq;
eq_of_seq_from_element_equality eq sp_xy sp_zw;
SP.foldm_snoc_equality add sp_xy sp_zw
in
matrix_equiv_from_proof eq (matrix_mul add mul mx my) (matrix_mul add mul mz mw) aux | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_ignores_out_of_range_update_lemma | val drop_ignores_out_of_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) | val drop_ignores_out_of_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) | let drop_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
drop (update s i v) n == drop s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
drop_ignores_out_of_range_update_helper s i v n
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 620,
"start_col": 8,
"start_line": 608
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1)
private let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
)
#push-options "--z3rlimit 20"
private let rec take_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s
/\ length (take s n) = n)
(ensures take (update s i v) n == update (take s n) i v) =
match s with
| hd :: tl -> if i = 0 then () else (update_maintains_length_lemma() ; take_commutes_with_in_range_update_helper tl (i - 1) v (n - 1))
#pop-options
private let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (take s n) = n); // triggers take_length_fact
take_commutes_with_in_range_update_helper s i v n
)
private let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
take (update s i v) n == take s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
take_ignores_out_of_range_update_helper s i v n
)
#push-options "--fuel 2 --ifuel 1 --z3rlimit_factor 4"
private let rec drop_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s
/\ length (drop s n) = length s - n)
(ensures drop (update s i v) n ==
update (drop s n) (i - n) v) =
match s with
| hd :: tl ->
if n = 0
then ()
else (
update_maintains_length_lemma ();
drop_length_lemma ();
drop_commutes_with_in_range_update_helper tl (i - 1) v (n - 1)
)
#pop-options
private let drop_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
drop (update s i v) n == update (drop s n) (i - n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (drop s n) = length s - n); // triggers drop_length_fact
drop_commutes_with_in_range_update_helper s i v n
)
private let rec drop_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s)
(ensures drop (update s i v) n == drop s n) =
match s with
| hd :: tl -> if i = 0 then () else drop_ignores_out_of_range_update_helper tl (i - 1) v (n - 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma (requires FStar.Sequence.Base.update_maintains_length_fact)
(ensures FStar.Sequence.Base.drop_ignores_out_of_range_update_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.drop",
"FStar.Sequence.Base.update",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.Sequence.Base.drop_ignores_out_of_range_update_helper",
"Prims._assert",
"Prims.op_Equality",
"FStar.Sequence.Base.update_maintains_length_fact",
"FStar.Sequence.Base.drop_ignores_out_of_range_update_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let drop_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat) . i < n && n <= length s ==>
drop (update s i v) n == drop s n
with introduce _ ==> _
with given_antecedent. (assert (length (update s i v) = length s);
drop_ignores_out_of_range_update_helper s i v n) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.update_then_index_helper | val update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) | val update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) | let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 244,
"start_col": 8,
"start_line": 233
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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: Prims.list ty ->
i: Prims.nat{i < FStar.Sequence.Base.length s} ->
v: ty ->
n: Prims.nat{n < FStar.Sequence.Base.length (FStar.Sequence.Base.update s i v)}
-> FStar.Pervasives.Lemma (requires n < FStar.Sequence.Base.length s)
(ensures
FStar.Sequence.Base.index (FStar.Sequence.Base.update s i v) n ==
(match i = n with
| true -> v
| _ -> FStar.Sequence.Base.index s n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.update",
"Prims.op_BarBar",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Sequence.Base.update_then_index_helper",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.squash",
"Prims.eq2",
"FStar.Sequence.Base.index",
"Prims.l_or",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
| match s with
| hd :: tl -> if i = 0 || n = 0 then () else update_then_index_helper tl (i - 1) v (n - 1) | false |
FStar.Matrix.fst | FStar.Matrix.matrix_right_mul_identity_aux_2 | val matrix_right_mul_identity_aux_2
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k = j + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)))
)
`eq.eq`
(ijth mx i j)) | val matrix_right_mul_identity_aux_2
(#c #eq #m: _)
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m)
(k: nat{k = j + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)))
)
`eq.eq`
(ijth mx i j)) | let matrix_right_mul_identity_aux_2 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=j+1})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` ijth mx i j) =
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j) | {
"file_name": "ulib/FStar.Matrix.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 61,
"end_line": 857,
"start_col": 0,
"start_line": 828
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Author: A. Rozanov
*)
(*
In this module we provide basic definitions to work with matrices via
seqs, and define transpose transform together with theorems that assert
matrix fold equality of original and transposed matrices.
*)
module FStar.Matrix
module CE = FStar.Algebra.CommMonoid.Equiv
module CF = FStar.Algebra.CommMonoid.Fold
module SP = FStar.Seq.Permutation
module SB = FStar.Seq.Base
module SProp = FStar.Seq.Properties
module ML = FStar.Math.Lemmas
open FStar.IntegerIntervals
open FStar.Mul
open FStar.Seq.Equiv
(*
A little glossary that might help reading this file
We don't list common terms like associativity and reflexivity.
lhs, rhs left hand side, right hand side
liat subsequence of all elements except the last (tail read backwards)
snoc construction of sequence from a pair (liat, last) (cons read backwards)
un_snoc decomposition of sequence into a pair (liat, last)
foldm sum or product of all elements in a sequence using given CommMonoid
foldm_snoc recursively defined sum/product of a sequence, starting from the last element
congruence respect of equivalence ( = ) by a binary operation ( * ), a=b ==> a*x = b*x
unit identity element (xu=x, ux=x) (not to be confused with invertible elements)
*)
type matrix c m n = z:SB.seq c { SB.length z = m*n }
let seq_of_matrix #c #m #n mx = mx
let ijth #c #m #n mx i j = SB.index mx (get_ij m n i j)
let ijth_lemma #c #m #n mx i j
: Lemma (ijth mx i j == SB.index (seq_of_matrix mx) (get_ij m n i j)) = ()
let matrix_of_seq #c m n s = s
let foldm #c #eq #m #n cm mx = SP.foldm_snoc cm mx
let matrix_fold_equals_fold_of_seq #c #eq #m #n cm mx
: Lemma (ensures foldm cm mx `eq.eq` SP.foldm_snoc cm (seq_of_matrix mx)) [SMTPat(foldm cm mx)]
= eq.reflexivity (foldm cm mx)
let matrix_fold_internal #c #eq #m #n (cm:CE.cm c eq) (mx: matrix c m n)
: Lemma (ensures foldm cm mx == SP.foldm_snoc cm mx) = ()
(* A flattened matrix (seq) constructed from generator function
Notice how the domains of both indices are strictly controlled. *)
let init #c (#m #n: pos) (generator: matrix_generator c m n)
: matrix_of generator =
let mn = m * n in
let generator_ij ij = generator (get_i m n ij) (get_j m n ij) in
let flat_indices = indices_seq mn in
let result = SProp.map_seq generator_ij flat_indices in
SProp.map_seq_len generator_ij flat_indices;
assert (SB.length result == SB.length flat_indices);
let aux (i: under m) (j: under n)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) (get_ij m n i j) == generator i j)
= consistency_of_i_j m n i j;
consistency_of_ij m n (get_ij m n i j);
assert (generator_ij (get_ij m n i j) == generator i j);
SProp.map_seq_index generator_ij flat_indices (get_ij m n i j) in
let aux1 (ij: under mn)
: Lemma (SB.index (SProp.map_seq generator_ij flat_indices) ij == generator_ij ij)
= SProp.map_seq_index generator_ij flat_indices ij in
FStar.Classical.forall_intro aux1;
FStar.Classical.forall_intro_2 aux;
result
private let matrix_seq #c #m #n (gen: matrix_generator c m n) : (t:SB.seq c{ (SB.length t = (m*n)) /\
(forall (i: under m) (j: under n). SB.index t (get_ij m n i j) == gen i j) /\
(forall(ij: under (m*n)). SB.index t ij == gen (get_i m n ij) (get_j m n ij))
}) = init gen
(* This auxiliary lemma establishes the decomposition of the seq-matrix
into the concatenation of its first (m-1) rows and its last row (thus snoc) *)
let matrix_append_snoc_lemma #c (#m #n: pos) (generator: matrix_generator c m n)
: Lemma (matrix_seq generator == (SB.slice (matrix_seq generator) 0 ((m-1)*n))
`SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
(SB.append (SB.slice (matrix_seq generator) 0 ((m-1)*n))
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
let matrix_seq_decomposition_lemma #c (#m:greater_than 1) (#n: pos) (generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) ==
SB.append (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)))
(* This auxiliary lemma establishes the equality of the fold of the entire matrix
to the op of folds of (the submatrix of the first (m-1) rows) and (the last row). *)
let matrix_fold_snoc_lemma #c #eq
(#m: not_less_than 2)
(#n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (assert ((m-1)*n < m*n);
SP.foldm_snoc cm (matrix_seq generator) `eq.eq`
cm.mult (SP.foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(SP.foldm_snoc cm (SB.slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n))))
= SB.lemma_eq_elim (matrix_seq generator)
((matrix_seq #c #(m-1) #n generator) `SB.append`
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n)));
SP.foldm_snoc_append cm (matrix_seq #c #(m-1) #n generator)
(SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(*
There are many auxiliary lemmas like this that are extracted because
lemma_eq_elim invocations often impact verification speed more than
one might expect they would.
*)
let matrix_submatrix_lemma #c (#m: not_less_than 2) (#n: pos)
(generator: matrix_generator c m n)
: Lemma ((matrix_seq generator) == (matrix_seq (fun (i:under(m-1)) (j:under n) -> generator i j)
`SB.append` SB.init n (generator (m-1))))
= SB.lemma_eq_elim (matrix_seq (fun (i:under (m-1)) (j:under n) -> generator i j))
(matrix_seq #c #(m-1) #n generator);
SB.lemma_eq_elim (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
(SB.init n (generator (m-1)));
matrix_seq_decomposition_lemma generator
let matrix_seq_of_one_row_matrix #c #m #n (generator : matrix_generator c m n)
: Lemma (requires m==1)
(ensures matrix_seq generator == (SB.init n (generator 0))) =
SB.lemma_eq_elim (matrix_seq generator) (SB.init n (generator 0))
let one_row_matrix_fold_aux #c #eq #m #n (cm:CE.cm c eq) (generator : matrix_generator c m n) : Lemma
(requires m=1)
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
let lhs_seq = matrix_seq generator in
let rhs_seq = SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))) in
let lhs = SP.foldm_snoc cm (matrix_seq generator) in
let rhs = SP.foldm_snoc cm rhs_seq in
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
SB.lemma_eq_elim (SB.create 1 (SP.foldm_snoc cm (SB.init n (generator 0))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))));
matrix_seq_of_one_row_matrix generator;
eq.symmetry rhs lhs
let fold_of_subgen_aux #c #eq (#m:pos{m>1}) #n (cm: CE.cm c eq) (gen: matrix_generator c m n) (subgen: matrix_generator c (m-1) n) : Lemma
(requires subgen == (fun (i: under (m-1)) (j: under n) -> gen i j))
(ensures forall (i: under (m-1)). SP.foldm_snoc cm (SB.init n (subgen i)) ==
SP.foldm_snoc cm (SB.init n (gen i))) =
let aux_pat (i: under (m-1)) : Lemma (SP.foldm_snoc cm (SB.init n (subgen i))
== SP.foldm_snoc cm (SB.init n (gen i))) =
SB.lemma_eq_elim (SB.init n (subgen i)) (SB.init n (gen i)) in
Classical.forall_intro aux_pat
let arithm_aux (m: pos{m>1}) (n: pos) : Lemma ((m-1)*n < m*n) = ()
let terminal_case_aux #c #eq (#p:pos{p=1}) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m<=p}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
= one_row_matrix_fold_aux cm generator
#push-options "--ifuel 0 --fuel 1 --z3rlimit 10"
let terminal_case_two_aux #c #eq (#p:pos) #n (cm:CE.cm c eq) (generator: matrix_generator c p n) (m: pos{m=1}) : Lemma
(ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
=
SP.foldm_snoc_singleton cm (SP.foldm_snoc cm (SB.init n (generator 0)));
assert (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (generator 0)));
let line = SB.init n (generator 0) in
let slice = SB.slice (matrix_seq generator) 0 n in
let aux (ij: under n) : Lemma (SB.index slice ij == SB.index line ij) =
Math.Lemmas.small_div ij n;
Math.Lemmas.small_mod ij n
in Classical.forall_intro aux;
SB.lemma_eq_elim line slice;
eq.symmetry (SP.foldm_snoc cm (SB.init m (fun (i:under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(SP.foldm_snoc cm line)
#pop-options
let liat_equals_init #c (m:pos) (gen: under m -> c)
: Lemma (fst (SProp.un_snoc (SB.init m gen)) == SB.init (m-1) gen) =
SB.lemma_eq_elim (fst (SProp.un_snoc (SB.init m gen))) (SB.init (m-1) gen)
let math_aux (m n: pos) (j: under n) : Lemma (j+((m-1)*n) < m*n) = ()
let math_aux_2 (m n: pos) (j: under n) : Lemma (get_j m n (j+(m-1)*n) == j)
=
Math.Lemmas.modulo_addition_lemma j n (m-1);
Math.Lemmas.small_mod j n
let math_aux_3 (m n: pos) (j: under n) : Lemma (get_i m n (j+(m-1)*n) == (m-1))
=
Math.Lemmas.division_addition_lemma j n (m-1);
Math.Lemmas.small_div j n
let math_aux_4 (m n: pos) (j: under n) : Lemma ((j+((m-1)*n)) - ((m-1)*n) == j) = ()
let seq_eq_from_member_eq #c (n: pos) (p q: (z:SB.seq c{SB.length z=n}))
(proof: (i: under n) -> Lemma (SB.index p i == SB.index q i))
: Lemma (p == q) =
Classical.forall_intro proof;
SB.lemma_eq_elim p q
let math_wut_lemma (x: pos) : Lemma (requires x>1) (ensures x-1 > 0) = ()
(* This proof used to be very unstable, so I rewrote it with as much precision
and control over lambdas as possible.
I also left intact some trivial auxiliaries and the quake option
in order to catch regressions the moment they happen instead of several
releases later -- Alex *)
#push-options "--ifuel 0 --fuel 0 --z3rlimit 15"
#restart-solver
let rec matrix_fold_equals_double_fold #c #eq (#p:pos) #n (cm:CE.cm c eq)
(generator: matrix_generator c p n) (m: pos{m<=p})
: Lemma (ensures SP.foldm_snoc cm (SB.slice (seq_of_matrix (init generator)) 0 (m*n)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))))
(decreases m) =
if p=1 then terminal_case_aux cm generator m
else if m=1 then terminal_case_two_aux cm generator m
else
let lhs_seq = (SB.slice (matrix_seq generator) 0 (m*n)) in
let rhs_seq_gen = fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq_subgen = fun (i: under (m-1)) -> SP.foldm_snoc cm (SB.init n (generator i)) in
let rhs_seq = SB.init m rhs_seq_gen in
let lhs = SP.foldm_snoc cm lhs_seq in
let rhs = SP.foldm_snoc cm rhs_seq in
let matrix = lhs_seq in
let submatrix = SB.slice (matrix_seq generator) 0 ((m-1)*n) in
let last_row = SB.slice (matrix_seq generator) ((m-1)*n) (m*n) in
SB.lemma_len_slice (matrix_seq generator) ((m-1)*n) (m*n);
assert (SB.length last_row = n);
SB.lemma_eq_elim matrix (SB.append submatrix last_row);
SP.foldm_snoc_append cm submatrix last_row;
matrix_fold_equals_double_fold #c #eq #p #n cm generator (m-1);
SB.lemma_eq_elim (SB.init (m-1) rhs_seq_gen)
(SB.init (m-1) rhs_seq_subgen);
let aux (j: under n) : Lemma (SB.index last_row j == generator (m-1) j) =
SB.lemma_index_app2 submatrix last_row (j+((m-1)*n));
math_aux_2 m n j;
math_aux_3 m n j;
math_aux_4 m n j;
() in Classical.forall_intro aux;
let rhs_liat, rhs_last = SProp.un_snoc rhs_seq in
let rhs_last_seq = SB.init n (generator (m-1)) in
liat_equals_init m rhs_seq_gen;
SP.foldm_snoc_decomposition cm rhs_seq;
let aux_2 (j: under n) : Lemma (SB.index last_row j == SB.index rhs_last_seq j) = () in
seq_eq_from_member_eq n last_row rhs_last_seq aux_2;
SB.lemma_eq_elim rhs_liat (SB.init (m-1) rhs_seq_gen);
cm.commutativity (SP.foldm_snoc cm submatrix) (SP.foldm_snoc cm last_row);
eq.transitivity lhs (SP.foldm_snoc cm submatrix `cm.mult` SP.foldm_snoc cm last_row)
(SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix);
eq.reflexivity (SP.foldm_snoc cm last_row);
cm.congruence (SP.foldm_snoc cm last_row) (SP.foldm_snoc cm submatrix)
(SP.foldm_snoc cm last_row) (SP.foldm_snoc cm (SB.init (m-1) rhs_seq_subgen));
eq.transitivity lhs (SP.foldm_snoc cm last_row `cm.mult` SP.foldm_snoc cm submatrix) rhs
#pop-options
let matrix_fold_equals_fold_of_seq_folds #c #eq #m #n cm generator : Lemma
(ensures foldm cm (init generator) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) /\
SP.foldm_snoc cm (seq_of_matrix (init generator)) `eq.eq`
SP.foldm_snoc cm (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))) =
matrix_fold_equals_double_fold cm generator m;
assert ((SB.slice (seq_of_matrix (init generator)) 0 (m*n)) == seq_of_matrix (init generator));
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i))))
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i))));
assert ((SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (generator i)))) ==
(SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (generator i)))));
()
(* This auxiliary lemma shows that the fold of the last line of a matrix
is equal to the corresponding fold of the generator function *)
let matrix_last_line_equals_gen_fold #c #eq
(#m #n: pos)
(cm: CE.cm c eq)
(generator: matrix_generator c m n)
: Lemma (SP.foldm_snoc cm (SB.slice (matrix_seq generator) ((m-1)*n) (m*n))
`eq.eq` CF.fold cm 0 (n-1) (generator (m-1))) =
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
assert (matrix_seq generator == seq_of_matrix (init generator));
let init = SB.init #c in
let lemma_eq_elim = SB.lemma_eq_elim #c in
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init n (generator (m-1)));
let g : ifrom_ito 0 (n-1) -> c = generator (m-1) in
CF.fold_equals_seq_foldm cm 0 (n-1) g;
let gen = CF.init_func_from_expr g 0 (n-1) in
eq.reflexivity (foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
lemma_eq_elim (slice (matrix_seq generator) ((m-1)*n) (m*n))
(init (closed_interval_size 0 (n-1)) gen);
eq.symmetry (CF.fold cm 0 (n-1) (generator (m-1)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen));
eq.transitivity (foldm_snoc cm (slice (matrix_seq generator) ((m-1)*n) (m*n)))
(foldm_snoc cm (init (closed_interval_size 0 (n-1)) gen))
(CF.fold cm 0 (n-1) (generator (m-1)))
(* This lemma proves that a matrix fold is the same thing as double-fold of
its generator function against full indices ranges *)
#push-options "--ifuel 0 --fuel 0"
let rec matrix_fold_aux #c #eq // lemma needed for precise generator domain control
(#gen_m #gen_n: pos) // full generator domain
(cm: CE.cm c eq)
(m: ifrom_ito 1 gen_m) (n: ifrom_ito 1 gen_n) //subdomain
(generator: matrix_generator c gen_m gen_n)
: Lemma (ensures SP.foldm_snoc cm (matrix_seq #c #m #n generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i)))
(decreases m) =
Classical.forall_intro_2 (ijth_lemma (init generator));
let slice = SB.slice #c in
let foldm_snoc = SP.foldm_snoc #c #eq in
let lemma_eq_elim = SB.lemma_eq_elim #c in
if m = 1 then begin
matrix_fold_equals_fold_of_seq cm (init generator);
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
CF.fold_singleton_lemma cm 0 (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i));
assert (CF.fold cm 0 (m-1) (fun (i: under m) -> CF.fold cm 0 (n-1) (generator i))
== CF.fold cm 0 (n-1) (generator 0))
end else begin
Classical.forall_intro_3 (Classical.move_requires_3 eq.transitivity);
matrix_fold_aux cm (m-1) n generator;
let outer_func (i: under m) = CF.fold cm 0 (n-1) (generator i) in
let outer_func_on_subdomain (i: under (m-1)) = CF.fold cm 0 (n-1) (generator i) in
CF.fold_equality cm 0 (m-2) outer_func_on_subdomain outer_func;
CF.fold_snoc_decomposition cm 0 (m-1) outer_func;
matrix_fold_snoc_lemma #c #eq #m #n cm generator;
matrix_last_line_equals_gen_fold #c #eq #m #n cm generator;
cm.congruence (foldm_snoc cm (matrix_seq #c #(m-1) #n generator))
(foldm_snoc cm (slice (matrix_seq #c #m #n generator) ((m-1)*n) (m*n)))
(CF.fold cm 0 (m-2) outer_func)
(CF.fold cm 0 (n-1) (generator (m-1)))
end
#pop-options
(* This lemma establishes that the fold of a matrix is equal to
nested Algebra.CommMonoid.Fold.fold over the matrix generator *)
let matrix_fold_equals_func_double_fold #c #eq #m #n cm generator
: Lemma (foldm cm (init generator) `eq.eq`
CF.fold cm 0 (m-1) (fun (i:under m) -> CF.fold cm 0 (n-1) (generator i)))
= matrix_fold_aux cm m n generator
(* This function provides the transposed matrix generator, with indices swapped
Notice how the forall property of the result function is happily proved
automatically by z3 :) *)
let transposed_matrix_gen #c #m #n (generator: matrix_generator c m n)
: (f: matrix_generator c n m { forall i j. f j i == generator i j })
= fun j i -> generator i j
(* This lemma shows that the transposed matrix is
a permutation of the original one *)
let matrix_transpose_is_permutation #c #m #n generator
: Lemma (SP.is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)) =
let matrix_transposed_eq_lemma #c (#m #n: pos)
(gen: matrix_generator c m n)
(ij: under (m*n))
: Lemma (SB.index (seq_of_matrix (init gen)) ij ==
SB.index (seq_of_matrix (init (transposed_matrix_gen gen))) (transpose_ji m n ij))
=
ijth_lemma (init gen) (get_i m n ij) (get_j m n ij);
ijth_lemma (init (transposed_matrix_gen gen))
(get_i n m (transpose_ji m n ij))
(get_j n m (transpose_ji m n ij));
() in
let transpose_inequality_lemma (m n: pos) (ij: under (m*n)) (kl: under (n*m))
: Lemma (requires kl <> ij) (ensures transpose_ji m n ij <> transpose_ji m n kl) =
dual_indices m n ij;
dual_indices m n kl in
Classical.forall_intro (matrix_transposed_eq_lemma generator);
Classical.forall_intro_2 (Classical.move_requires_2
(transpose_inequality_lemma m n));
SP.reveal_is_permutation (seq_of_matrix (init generator))
(seq_of_matrix (init (transposed_matrix_gen generator)))
(transpose_ji m n)
(* Fold over matrix equals fold over transposed matrix *)
let matrix_fold_equals_fold_of_transpose #c #eq #m #n
(cm: CE.cm c eq)
(gen: matrix_generator c m n)
: Lemma (foldm cm (init gen) `eq.eq`
foldm cm (init (transposed_matrix_gen gen))) =
let matrix_seq #c #m #n (g: matrix_generator c m n) = (seq_of_matrix (init g)) in
let matrix_mn = matrix_seq gen in
let matrix_nm = matrix_seq (transposed_matrix_gen gen) in
matrix_transpose_is_permutation gen;
SP.foldm_snoc_perm cm (matrix_seq gen)
(matrix_seq (transposed_matrix_gen gen))
(transpose_ji m n);
matrix_fold_equals_fold_of_seq cm (init gen);
matrix_fold_equals_fold_of_seq cm (init (transposed_matrix_gen gen));
eq.symmetry (foldm cm (init (transposed_matrix_gen gen)))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq gen))
(SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)));
eq.transitivity (foldm cm (init gen)) (SP.foldm_snoc cm (matrix_seq (transposed_matrix_gen gen)))
(foldm cm (init (transposed_matrix_gen gen)))
let matrix_eq_fun #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) =
eq_of_seq eq (seq_of_matrix ma) (seq_of_matrix mb)
(*
Matrix equivalence, defined as element-wise equivalence of its underlying
flattened sequence, is constructed trivially from the element equivalence
and the lemmas defined above.
*)
let matrix_equiv #c (eq: CE.equiv c) (m n: pos) : CE.equiv (matrix c m n) =
CE.EQ (matrix_eq_fun eq)
(fun m -> eq_of_seq_reflexivity eq (seq_of_matrix m))
(fun ma mb -> eq_of_seq_symmetry eq (seq_of_matrix ma) (seq_of_matrix mb))
(fun ma mb mc -> eq_of_seq_transitivity eq (seq_of_matrix ma) (seq_of_matrix mb) (seq_of_matrix mc))
(* Equivalence of matrices means equivalence of all corresponding elements *)
let matrix_equiv_ijth #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n) (i: under m) (j: under n)
: Lemma (requires (matrix_equiv eq m n).eq ma mb) (ensures ijth ma i j `eq.eq` ijth mb i j) =
eq_of_seq_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* Equivalence of all corresponding elements means equivalence of matrices *)
let matrix_equiv_from_element_eq #c (#m #n: pos) (eq: CE.equiv c) (ma mb: matrix c m n)
: Lemma (requires (forall (i: under m) (j: under n). ijth ma i j `eq.eq` ijth mb i j))
(ensures matrix_eq_fun eq ma mb) =
assert (SB.length (seq_of_matrix ma) = SB.length (seq_of_matrix mb));
let s1 = seq_of_matrix ma in
let s2 = seq_of_matrix mb in
assert (forall (ij: under (m*n)). SB.index s1 ij == ijth ma (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s2 ij == ijth mb (get_i m n ij) (get_j m n ij));
assert (forall (ij: under (m*n)). SB.index s1 ij `eq.eq` SB.index s2 ij);
eq_of_seq_from_element_equality eq (seq_of_matrix ma) (seq_of_matrix mb)
(* We construct addition CommMonoid from the following definitions *)
let matrix_add_is_associative #c #eq #m #n (add: CE.cm c eq) (ma mb mc: matrix c m n)
: Lemma (matrix_add add (matrix_add add ma mb) mc `(matrix_equiv eq m n).eq`
matrix_add add ma (matrix_add add mb mc)) =
matrix_equiv_from_proof eq
(matrix_add add (matrix_add add ma mb) mc)
(matrix_add add ma (matrix_add add mb mc))
(fun i j -> add.associativity (ijth ma i j) (ijth mb i j) (ijth mc i j))
let matrix_add_is_commutative #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb: matrix c m n)
: Lemma (matrix_add add ma mb `(matrix_equiv eq m n).eq` matrix_add add mb ma) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mb ma)
(fun i j -> add.commutativity (ijth ma i j) (ijth mb i j))
let matrix_add_congruence #c #eq (#m #n: pos) (add: CE.cm c eq) (ma mb mc md: matrix c m n)
: Lemma (requires matrix_eq_fun eq ma mc /\ matrix_eq_fun eq mb md)
(ensures matrix_add add ma mb `matrix_eq_fun eq` matrix_add add mc md) =
matrix_equiv_from_proof eq (matrix_add add ma mb) (matrix_add add mc md)
(fun i j -> matrix_equiv_ijth eq ma mc i j;
matrix_equiv_ijth eq mb md i j;
add.congruence (ijth ma i j) (ijth mb i j)
(ijth mc i j) (ijth md i j))
let matrix_add_zero #c #eq (add: CE.cm c eq) (m n: pos)
: (z: matrix c m n { forall (i: under m) (j: under n). ijth z i j == add.unit })
= matrix_of_seq m n (SB.create (m*n) add.unit)
let matrix_add_identity #c #eq (add: CE.cm c eq) (#m #n: pos) (mx: matrix c m n)
: Lemma (matrix_add add (matrix_add_zero add m n) mx `matrix_eq_fun eq` mx) =
matrix_equiv_from_proof eq (matrix_add add (matrix_add_zero add m n) mx) mx
(fun i j -> add.identity (ijth mx i j))
let matrix_add_comm_monoid #c #eq (add: CE.cm c eq) (m n: pos)
: CE.cm (matrix c m n) (matrix_equiv eq m n)
= CE.CM (matrix_add_zero add m n)
(matrix_add add)
(matrix_add_identity add)
(matrix_add_is_associative add)
(matrix_add_is_commutative add)
(matrix_add_congruence add)
(* equivalence of addressing styles *)
let matrix_row_col_lemma #c #m #n (mx: matrix c m n) (i: under m) (j: under n)
: Lemma (ijth mx i j == SB.index (row mx i) j /\ ijth mx i j == SB.index (col mx j) i) = ()
(*
See how lemma_eq_elim is defined, note the SMTPat there.
Invoking this is often more efficient in big proofs than invoking
lemma_eq_elim directly.
*)
let seq_of_products_lemma #c #eq (mul: CE.cm c eq) (s: SB.seq c) (t: SB.seq c {SB.length t == SB.length s})
(r: SB.seq c{SB.equal r (SB.init (SB.length s) (fun (i: under (SB.length s)) -> SB.index s i `mul.mult` SB.index t i))})
: Lemma (seq_of_products mul s t == r) = ()
let dot_lemma #c #eq add mul s t
: Lemma (dot add mul s t == SP.foldm_snoc add (seq_of_products mul s t)) = ()
let matrix_mul_gen #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p)
(i: under m) (k: under p)
= dot add mul (row mx i) (col my k)
let matrix_mul #c #eq #m #n #p (add mul: CE.cm c eq) (mx: matrix c m n) (my: matrix c n p)
= init (matrix_mul_gen add mul mx my)
(* the following lemmas improve verification performance. *)
(* Sometimes this fact gets lost and needs an explicit proof *)
let seq_last_index #c (s: SB.seq c{SB.length s > 0})
: Lemma (SProp.last s == SB.index s (SB.length s - 1)) = ()
(* It often takes assert_norm to obtain the fact that,
(fold s == last s `op` fold (slice s 0 (length s - 1))).
Invoking this lemma instead offers a more stable option. *)
let seq_fold_decomposition #c #eq (cm: CE.cm c eq) (s: SB.seq c{SB.length s > 0})
: Lemma (SP.foldm_snoc cm s == cm.mult (SProp.last s) (SP.foldm_snoc cm (fst (SProp.un_snoc s)))) = ()
(* Using common notation for algebraic operations instead of `mul` / `add` infix
simplifies the code and makes it more compact. *)
let rec foldm_snoc_distributivity_left #c #eq (mul add: CE.cm c eq) (a: c) (s: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult a (SP.foldm_snoc add s) `eq.eq`
SP.foldm_snoc add (const_op_seq mul a s))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (const_op_seq mul a s) in
foldm_snoc_distributivity_left mul add a liat;
SB.lemma_eq_elim rhs_liat (const_op_seq mul a liat);
eq.reflexivity rhs_last;
add.congruence rhs_last (a*sum liat) rhs_last (sum rhs_liat);
eq.transitivity (a*sum s) (rhs_last + a*sum liat) (rhs_last + sum rhs_liat)
let rec foldm_snoc_distributivity_right #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add (seq_op_const mul s a))
(decreases SB.length s) =
if SB.length s > 0 then
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let sum s = SP.foldm_snoc add s in
let liat, last = SProp.un_snoc s in
let rhs_liat, rhs_last = SProp.un_snoc (seq_op_const mul s a) in
foldm_snoc_distributivity_right mul add liat a;
SB.lemma_eq_elim rhs_liat (seq_op_const mul liat a);
eq.reflexivity rhs_last;
add.congruence rhs_last (sum liat*a) rhs_last (sum rhs_liat);
eq.transitivity (sum s*a) (rhs_last + sum liat*a) (rhs_last + sum rhs_liat)
let foldm_snoc_distributivity_right_eq #c #eq (mul add: CE.cm c eq) (s: SB.seq c) (a: c) (r: SB.seq c)
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul /\
SB.equal r (seq_op_const mul s a))
(ensures mul.mult (SP.foldm_snoc add s) a `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_right mul add s a
let foldm_snoc_distributivity_left_eq #c #eq (mul add: CE.cm c eq) (a: c)
(s: SB.seq c)
(r: SB.seq c{SB.equal r (const_op_seq mul a s)})
: Lemma (requires is_fully_distributive mul add /\ is_absorber add.unit mul)
(ensures (mul.mult a(SP.foldm_snoc add s)) `eq.eq`
SP.foldm_snoc add r)
= foldm_snoc_distributivity_left mul add a s
let matrix_mul_ijth #c #eq #m #n #k (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n k) i h
: Lemma (ijth (matrix_mul add mul mx my) i h == dot add mul (row mx i) (col my h)) = ()
let matrix_mul_ijth_as_sum #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
: Lemma (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)))) =
let r = SB.init n (fun (j: under n) -> mul.mult (ijth mx i j) (ijth my j k)) in
assert (ijth (matrix_mul add mul mx my) i k ==
SP.foldm_snoc add (seq_of_products mul (row mx i) (col my k)));
seq_of_products_lemma mul (row mx i) (col my k) r
let matrix_mul_ijth_eq_sum_of_seq #c #eq #m #n #p (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (i: under m) (k: under p)
(r: SB.seq c{r `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add r) = ()
let double_foldm_snoc_transpose_lemma #c #eq (#m #n: pos) (cm: CE.cm c eq) (f: under m -> under n -> c)
: Lemma (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))))) =
Classical.forall_intro_2 (Classical.move_requires_2 eq.symmetry);
let gen : matrix_generator c m n = f in
let mx = init gen in
let mx_seq = matrix_seq gen in
matrix_fold_equals_fold_of_seq_folds cm gen;
let aux (i: under m) : Lemma (SB.init n (gen i) == SB.init n (fun (j: under n) -> f i j))
= SB.lemma_eq_elim (SB.init n (gen i))(SB.init n (fun (j: under n) -> f i j))
in Classical.forall_intro aux;
SB.lemma_eq_elim (SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (gen i))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
SB.lemma_eq_elim (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
(SB.init m (fun i -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))));
matrix_transpose_is_permutation gen;
matrix_fold_equals_fold_of_transpose cm gen;
let trans_gen = transposed_matrix_gen gen in
let mx_trans = init trans_gen in
let mx_trans_seq = matrix_seq trans_gen in
matrix_fold_equals_fold_of_seq_folds cm trans_gen;
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j)))));
let aux_tr_lemma (j: under n)
: Lemma ((SB.init m (trans_gen j)) == (SB.init m (fun (i: under m) -> f i j)))
= SB.lemma_eq_elim (SB.init m (trans_gen j)) (SB.init m (fun (i: under m) -> f i j))
in Classical.forall_intro aux_tr_lemma;
SB.lemma_eq_elim (SB.init n (fun j -> SP.foldm_snoc cm (SB.init m (trans_gen j))))
(SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j))));
assert (foldm cm mx_trans `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))));
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx)
(foldm cm mx_trans);
eq.transitivity (SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))))
(foldm cm mx_trans)
(SP.foldm_snoc cm (SB.init n (fun (j:under n) -> SP.foldm_snoc cm (SB.init m (fun (i: under m) -> f i j)))))
let matrix_mul_ijth_eq_sum_of_seq_for_init #c #eq #m #n #p (add mul: CE.cm c eq)
(mx: matrix c m n) (my: matrix c n p) i k
(f: under n -> c { SB.init n f `SB.equal` seq_of_products mul (row mx i) (col my k)})
: Lemma (ijth (matrix_mul add mul mx my) i k == SP.foldm_snoc add (SB.init n f)) = ()
let double_foldm_snoc_of_equal_generators #c #eq (#m #n: pos)
(cm: CE.cm c eq)
(f g: under m -> under n -> c)
: Lemma (requires (forall (i: under m) (j: under n). f i j `eq.eq` g i j))
(ensures SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j))))
`eq.eq` SP.foldm_snoc cm (SB.init m (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j))))) =
let aux i : Lemma (SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)) `eq.eq`
SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
= SP.foldm_snoc_of_equal_inits cm (fun j -> f i j) (fun j -> g i j) in
Classical.forall_intro aux;
SP.foldm_snoc_of_equal_inits cm (fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> f i j)))
(fun (i: under m) -> SP.foldm_snoc cm (SB.init n (fun (j: under n) -> g i j)))
#push-options "--z3rlimit 15 --ifuel 0 --fuel 0"
let matrix_mul_is_associative #c #eq #m #n #p #q (add: CE.cm c eq)
(mul: CE.cm c eq{is_fully_distributive mul add /\ is_absorber add.unit mul})
(mx: matrix c m n) (my: matrix c n p) (mz: matrix c p q)
: Lemma (matrix_eq_fun eq ((matrix_mul add mul mx my) `matrix_mul add mul` mz)
(matrix_mul add mul mx (matrix_mul add mul my mz))) =
let rhs = mx `matrix_mul add mul` (my `matrix_mul add mul` mz) in
let lhs = (mx `matrix_mul add mul` my) `matrix_mul add mul` mz in
let mxy = matrix_mul add mul mx my in
let myz = matrix_mul add mul my mz in
let ((+), ( * ), (=)) = add.mult, mul.mult, eq.eq in
let aux i l : squash (ijth lhs i l = ijth rhs i l) =
let sum_j (f: under n -> c) = SP.foldm_snoc add (SB.init n f) in
let sum_k (f: under p -> c) = SP.foldm_snoc add (SB.init p f) in
let xy_products_init k j = ijth mx i j * ijth my j k in
let xy_cell_as_sum k = sum_j (xy_products_init k) in
let xy_cell_lemma k : Lemma (ijth mxy i k == xy_cell_as_sum k) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx my i k (xy_products_init k)
in Classical.forall_intro xy_cell_lemma;
let xy_z_products_init k = xy_cell_as_sum k * ijth mz k l in
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mxy mz i l xy_z_products_init;
let full_init_kj k j = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_jk j k = (ijth mx i j * ijth my j k) * ijth mz k l in
let full_init_rh j k = ijth mx i j * (ijth my j k * ijth mz k l) in
let sum_jk (f: (under n -> under p -> c)) = sum_j (fun j -> sum_k (fun k -> f j k)) in
let sum_kj (f: (under p -> under n -> c)) = sum_k (fun k -> sum_j (fun j -> f k j)) in
let xy_z_distr k : Lemma (((xy_cell_as_sum k) * (ijth mz k l)) = sum_j (full_init_kj k))
= foldm_snoc_distributivity_right_eq mul add (SB.init n (xy_products_init k)) (ijth mz k l)
(SB.init n (full_init_kj k))
in Classical.forall_intro xy_z_distr;
SP.foldm_snoc_of_equal_inits add xy_z_products_init
(fun k -> sum_j (full_init_kj k));
double_foldm_snoc_transpose_lemma add full_init_kj;
eq.transitivity (ijth lhs i l) (sum_kj full_init_kj)
(sum_jk full_init_jk);
let aux_rh j k : Lemma (full_init_jk j k = full_init_rh j k)
= mul.associativity (ijth mx i j) (ijth my j k) (ijth mz k l)
in Classical.forall_intro_2 aux_rh;
double_foldm_snoc_of_equal_generators add full_init_jk full_init_rh;
eq.transitivity (ijth lhs i l) (sum_jk full_init_jk) (sum_jk full_init_rh);
// now expand the right hand side, fully dual to the first part of the lemma.
let yz_products_init j k = ijth my j k * ijth mz k l in
let yz_cell_as_sum j = sum_k (yz_products_init j) in
let x_yz_products_init j = ijth mx i j * yz_cell_as_sum j in
let yz_cell_lemma j : Lemma (ijth myz j l == sum_k (yz_products_init j)) =
matrix_mul_ijth_eq_sum_of_seq_for_init add mul my mz j l (yz_products_init j);
() in Classical.forall_intro yz_cell_lemma;
matrix_mul_ijth_eq_sum_of_seq_for_init add mul mx myz i l x_yz_products_init;
let x_yz_distr j : Lemma (ijth mx i j * yz_cell_as_sum j = sum_k (full_init_rh j))
= foldm_snoc_distributivity_left_eq mul add (ijth mx i j) (SB.init p (yz_products_init j))
(SB.init p (full_init_rh j))
in Classical.forall_intro x_yz_distr;
SP.foldm_snoc_of_equal_inits add x_yz_products_init (fun j -> sum_k (full_init_rh j));
eq.symmetry (ijth rhs i l) (sum_jk full_init_rh);
eq.transitivity (ijth lhs i l) (sum_jk full_init_rh) (ijth rhs i l);
() in matrix_equiv_from_proof eq lhs rhs aux
#pop-options
let matrix_mul_unit_row_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((row (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(row (matrix_mul_unit add mul m) i
== ((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(row (matrix_mul_unit add mul m) i)
let matrix_mul_unit_col_lemma #c #eq m (add mul: CE.cm c eq) (i: under m)
: Lemma ((col (matrix_mul_unit add mul m) i
== (SB.create i add.unit) `SB.append`
((SB.create 1 mul.unit) `SB.append` (SB.create (m-i-1) add.unit))) /\
(col (matrix_mul_unit add mul m) i ==
((SB.create i add.unit) `SB.append` (SB.create 1 mul.unit)) `SB.append`
(SB.create (m-i-1) add.unit))) =
SB.lemma_eq_elim ((SB.create i add.unit `SB.append` SB.create 1 mul.unit)
`SB.append` (SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i);
SB.lemma_eq_elim ((SB.create i add.unit) `SB.append`
(SB.create 1 mul.unit `SB.append` SB.create (m-i-1) add.unit))
(col (matrix_mul_unit add mul m) i)
let seq_of_products_zeroes_lemma #c #eq #m (mul: CE.cm c eq)
(z: c{is_absorber z mul})
(s: SB.seq c{SB.length s == m})
: Lemma (ensures (eq_of_seq eq (seq_of_products mul (SB.create m z) s) (SB.create m z)))
= eq_of_seq_from_element_equality eq (seq_of_products mul (SB.create m z) s) (SB.create m z)
let rec foldm_snoc_zero_lemma #c #eq (add: CE.cm c eq) (zeroes: SB.seq c)
: Lemma (requires (forall (i: under (SB.length zeroes)). SB.index zeroes i `eq.eq` add.unit))
(ensures eq.eq (SP.foldm_snoc add zeroes) add.unit)
(decreases SB.length zeroes) =
if (SB.length zeroes < 1) then begin
assert_norm (SP.foldm_snoc add zeroes == add.unit);
eq.reflexivity add.unit
end else
let liat, last = SProp.un_snoc zeroes in
foldm_snoc_zero_lemma add liat;
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add zeroes;
eq.transitivity (SP.foldm_snoc add zeroes)
(add.mult add.unit add.unit)
add.unit
let matrix_mul_unit_ijth #c #eq (add mul: CE.cm c eq) m (i j: under m)
: Lemma (ijth (matrix_mul_unit add mul m) i j == (if i=j then mul.unit else add.unit))=()
let last_equals_index #c (s: SB.seq c{SB.length s > 0})
: Lemma ((snd (SProp.un_snoc s)) == SB.index s (SB.length s - 1)) = ()
let matrix_right_mul_identity_aux_0 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k=0})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
= eq.reflexivity add.unit
let rec matrix_right_mul_identity_aux_1 #c #eq #m
(add: CE.cm c eq)
(mul: CE.cm c eq{is_absorber add.unit mul})
(mx: matrix c m m)
(i j: under m) (k:nat{k<=j})
: Lemma (ensures SP.foldm_snoc add (SB.init k (fun (k: under m)
-> ijth mx i k `mul.mult`
ijth (matrix_mul_unit add mul m) k j))
`eq.eq` add.unit)
(decreases k)
= if k = 0 then matrix_right_mul_identity_aux_0 add mul mx i j k
else
let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat,last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j (k-1);
liat_equals_init k gen;
eq.reflexivity (SP.foldm_snoc add liat);
mul.congruence last (SP.foldm_snoc add liat) add.unit (SP.foldm_snoc add liat);
eq.transitivity (last * SP.foldm_snoc add liat)
(add.unit * SP.foldm_snoc add liat)
(add.unit);
eq.reflexivity (SP.foldm_snoc add (SB.init (k-1) gen));
matrix_mul_unit_ijth add mul m (k-1) j; // This one reduces the rlimits needs to default
add.congruence last (SP.foldm_snoc add liat) add.unit add.unit;
add.identity add.unit;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full)
(add.mult add.unit add.unit)
add.unit | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Properties.fsti.checked",
"FStar.Seq.Permutation.fsti.checked",
"FStar.Seq.Equiv.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.IntegerIntervals.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Algebra.CommMonoid.Fold.fsti.checked",
"FStar.Algebra.CommMonoid.Equiv.fst.checked"
],
"interface_file": true,
"source_file": "FStar.Matrix.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Seq.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Properties",
"short_module": "SProp"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IntegerIntervals",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "FStar.Seq.Permutation",
"short_module": "SP"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Fold",
"short_module": "CF"
},
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
add: FStar.Algebra.CommMonoid.Equiv.cm c eq ->
mul: FStar.Algebra.CommMonoid.Equiv.cm c eq {FStar.Matrix.is_absorber (CM?.unit add) mul} ->
mx: FStar.Matrix.matrix c m m ->
i: FStar.IntegerIntervals.under m ->
j: FStar.IntegerIntervals.under m ->
k: Prims.nat{k = j + 1}
-> FStar.Pervasives.Lemma
(ensures
EQ?.eq eq
(FStar.Seq.Permutation.foldm_snoc add
(FStar.Seq.Base.init k
(fun k ->
CM?.mult mul
(FStar.Matrix.ijth mx i k)
(FStar.Matrix.ijth (FStar.Matrix.matrix_mul_unit add mul m) k j))))
(FStar.Matrix.ijth mx i j)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Algebra.CommMonoid.Equiv.equiv",
"Prims.pos",
"FStar.Algebra.CommMonoid.Equiv.cm",
"FStar.Matrix.is_absorber",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__unit",
"FStar.Matrix.matrix",
"FStar.IntegerIntervals.under",
"Prims.nat",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Addition",
"FStar.Seq.Base.seq",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__transitivity",
"FStar.Seq.Permutation.foldm_snoc",
"FStar.Matrix.ijth",
"Prims.unit",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"FStar.Seq.Permutation.foldm_snoc_decomposition",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__commutativity",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__identity",
"FStar.Matrix.matrix_mul_unit_ijth",
"Prims.op_Subtraction",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__congruence",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__reflexivity",
"FStar.Matrix.liat_equals_init",
"FStar.Matrix.matrix_right_mul_identity_aux_1",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2",
"FStar.Seq.Properties.snoc",
"FStar.Pervasives.Native.fst",
"FStar.Pervasives.Native.snd",
"FStar.Seq.Properties.un_snoc",
"FStar.Seq.Base.init",
"FStar.Algebra.CommMonoid.Equiv.__proj__EQ__item__eq",
"FStar.Matrix.matrix_mul",
"FStar.Matrix.matrix_mul_unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let matrix_right_mul_identity_aux_2
#c
#eq
#m
(add: CE.cm c eq)
(mul: CE.cm c eq {is_absorber add.unit mul})
(mx: matrix c m m)
(i: under m)
(j: under m)
(k: nat{k = j + 1})
: Lemma
(ensures
(SP.foldm_snoc add
(SB.init k
(fun (k: under m) -> (ijth mx i k) `mul.mult` (ijth (matrix_mul_unit add mul m) k j)))
)
`eq.eq`
(ijth mx i j)) =
| let unit = matrix_mul_unit add mul m in
let mxu = matrix_mul add mul mx unit in
let ( * ) = mul.mult in
let ( $=$ ) = eq.eq in
let gen = fun (k: under m) -> ijth mx i k * ijth unit k j in
let full = SB.init k gen in
let liat, last = SProp.un_snoc full in
matrix_right_mul_identity_aux_1 add mul mx i j j;
liat_equals_init k gen;
mul.identity (ijth mx i j);
eq.reflexivity last;
add.congruence last (SP.foldm_snoc add liat) last add.unit;
matrix_mul_unit_ijth add mul m (k - 1) j;
add.identity last;
add.commutativity last add.unit;
mul.commutativity (ijth mx i j) mul.unit;
eq.transitivity (add.mult last add.unit) (add.mult add.unit last) last;
SP.foldm_snoc_decomposition add full;
eq.transitivity (SP.foldm_snoc add full) (add.mult last add.unit) last;
eq.transitivity last (mul.unit * ijth mx i j) (ijth mx i j);
eq.transitivity (SP.foldm_snoc add full) last (ijth mx i j) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.all_seq_facts_lemma | val all_seq_facts_lemma : unit -> Lemma (all_seq_facts u#a) | val all_seq_facts_lemma : unit -> Lemma (all_seq_facts u#a) | let all_seq_facts_lemma () : Lemma (all_seq_facts u#a) =
length_of_empty_is_zero_lemma u#a ();
length_zero_implies_empty_lemma u#a ();
singleton_length_one_lemma u#a ();
build_increments_length_lemma u#a ();
index_into_build_lemma u#a ();
append_sums_lengths_lemma u#a ();
index_into_singleton_lemma u#a ();
index_after_append_lemma u#a ();
update_maintains_length_lemma u#a ();
update_then_index_lemma u#a ();
contains_iff_exists_index_lemma u#a ();
empty_doesnt_contain_anything_lemma u#a ();
build_contains_equiv_lemma u#a ();
take_contains_equiv_exists_lemma u#a ();
drop_contains_equiv_exists_lemma u#a ();
equal_def_lemma u#a ();
extensionality_lemma u#a ();
is_prefix_def_lemma u#a ();
take_length_lemma u#a ();
index_into_take_lemma u#a ();
drop_length_lemma u#a ();
index_into_drop_lemma u#a ();
drop_index_offset_lemma u#a ();
append_then_take_or_drop_lemma u#a ();
take_commutes_with_in_range_update_lemma u#a ();
take_ignores_out_of_range_update_lemma u#a ();
drop_commutes_with_in_range_update_lemma u#a ();
drop_ignores_out_of_range_update_lemma u#a ();
drop_commutes_with_build_lemma u#a ();
rank_def_lemma u#a ();
element_ranks_less_lemma u#a ();
drop_ranks_less_lemma u#a ();
take_ranks_less_lemma u#a ();
append_take_drop_ranks_less_lemma u#a ();
drop_zero_lemma u#a ();
take_zero_lemma u#a ();
drop_then_drop_lemma u#a () | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 752,
"start_col": 0,
"start_line": 715
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1)
private let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
)
#push-options "--z3rlimit 20"
private let rec take_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s
/\ length (take s n) = n)
(ensures take (update s i v) n == update (take s n) i v) =
match s with
| hd :: tl -> if i = 0 then () else (update_maintains_length_lemma() ; take_commutes_with_in_range_update_helper tl (i - 1) v (n - 1))
#pop-options
private let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (take s n) = n); // triggers take_length_fact
take_commutes_with_in_range_update_helper s i v n
)
private let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
take (update s i v) n == take s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
take_ignores_out_of_range_update_helper s i v n
)
#push-options "--fuel 2 --ifuel 1 --z3rlimit_factor 4"
private let rec drop_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s
/\ length (drop s n) = length s - n)
(ensures drop (update s i v) n ==
update (drop s n) (i - n) v) =
match s with
| hd :: tl ->
if n = 0
then ()
else (
update_maintains_length_lemma ();
drop_length_lemma ();
drop_commutes_with_in_range_update_helper tl (i - 1) v (n - 1)
)
#pop-options
private let drop_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
drop (update s i v) n == update (drop s n) (i - n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (drop s n) = length s - n); // triggers drop_length_fact
drop_commutes_with_in_range_update_helper s i v n
)
private let rec drop_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s)
(ensures drop (update s i v) n == drop s n) =
match s with
| hd :: tl -> if i = 0 then () else drop_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let drop_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
drop (update s i v) n == drop s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
drop_ignores_out_of_range_update_helper s i v n
)
private let rec drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) =
match s with
| [] ->
assert (append s [v] == [v]);
assert (n == 0);
()
| hd :: tl -> if n = 0 then () else drop_commutes_with_build_helper tl v (n - 1)
private let drop_commutes_with_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (n: nat).
n <= length s ==> drop (build s v) n == build (drop s n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (build s v) = 1 + length s); // triggers build_increments_length_fact
drop_commutes_with_build_helper s v n
)
private let rank_def_lemma () : Lemma (rank_def_fact) =
()
private let element_ranks_less_lemma () : Lemma (element_ranks_less_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat). i < length s ==> rank (index s i) << rank s
with
introduce _ ==> _
with given_antecedent. (
contains_iff_exists_index_lemma ();
assert (contains s (index s i));
FLT.memP_precedes (index s i) s
)
private let rec drop_ranks_less_helper (ty: Type) (s: list ty) (i: nat)
: Lemma (requires 0 < i && i <= length s)
(ensures drop s i << s) =
match s with
| [] -> ()
| hd :: tl -> if i = 1 then () else drop_ranks_less_helper ty tl (i - 1)
private let drop_ranks_less_lemma () : Lemma (drop_ranks_less_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat).
0 < i && i <= length s ==> rank (drop s i) << rank s
with
introduce _ ==> _
with given_antecedent. (
drop_ranks_less_helper ty s i
)
private let take_ranks_less_lemma () : Lemma (take_ranks_less_fact) =
take_length_lemma ()
private let append_take_drop_ranks_less_lemma () : Lemma (append_take_drop_ranks_less_fact) =
take_length_lemma ();
drop_length_lemma ();
append_sums_lengths_lemma ()
private let drop_zero_lemma () : Lemma (drop_zero_fact) =
()
private let take_zero_lemma () : Lemma (take_zero_fact) =
()
private let rec drop_then_drop_helper (#ty: Type) (s: seq ty) (m: nat) (n: nat)
: Lemma (requires m + n <= length s /\ length (drop s m) = length s - m)
(ensures drop (drop s m) n == drop s (m + n)) =
match s with
| [] -> ()
| hd :: tl ->
if m = 0
then ()
else (
drop_length_lemma ();
drop_then_drop_helper tl (m - 1) n
)
private let drop_then_drop_lemma () : Lemma (requires drop_length_fact u#a) (ensures drop_then_drop_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (m: nat) (n: nat).
m + n <= length s ==> drop (drop s m) n == drop s (m + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s m) = length s - m); // triggers drop_length_fact
drop_then_drop_helper s m n
)
/// Finally, we use all the lemmas for all the facts to establish
/// `all_seq_facts`. To get all those facts in scope, one can
/// invoke `all_seq_facts_lemma`. | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.all_seq_facts) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Sequence.Base.drop_then_drop_lemma",
"FStar.Sequence.Base.take_zero_lemma",
"FStar.Sequence.Base.drop_zero_lemma",
"FStar.Sequence.Base.append_take_drop_ranks_less_lemma",
"FStar.Sequence.Base.take_ranks_less_lemma",
"FStar.Sequence.Base.drop_ranks_less_lemma",
"FStar.Sequence.Base.element_ranks_less_lemma",
"FStar.Sequence.Base.rank_def_lemma",
"FStar.Sequence.Base.drop_commutes_with_build_lemma",
"FStar.Sequence.Base.drop_ignores_out_of_range_update_lemma",
"FStar.Sequence.Base.drop_commutes_with_in_range_update_lemma",
"FStar.Sequence.Base.take_ignores_out_of_range_update_lemma",
"FStar.Sequence.Base.take_commutes_with_in_range_update_lemma",
"FStar.Sequence.Base.append_then_take_or_drop_lemma",
"FStar.Sequence.Base.drop_index_offset_lemma",
"FStar.Sequence.Base.index_into_drop_lemma",
"FStar.Sequence.Base.drop_length_lemma",
"FStar.Sequence.Base.index_into_take_lemma",
"FStar.Sequence.Base.take_length_lemma",
"FStar.Sequence.Base.is_prefix_def_lemma",
"FStar.Sequence.Base.extensionality_lemma",
"FStar.Sequence.Base.equal_def_lemma",
"FStar.Sequence.Base.drop_contains_equiv_exists_lemma",
"FStar.Sequence.Base.take_contains_equiv_exists_lemma",
"FStar.Sequence.Base.build_contains_equiv_lemma",
"FStar.Sequence.Base.empty_doesnt_contain_anything_lemma",
"FStar.Sequence.Base.contains_iff_exists_index_lemma",
"FStar.Sequence.Base.update_then_index_lemma",
"FStar.Sequence.Base.update_maintains_length_lemma",
"FStar.Sequence.Base.index_after_append_lemma",
"FStar.Sequence.Base.index_into_singleton_lemma",
"FStar.Sequence.Base.append_sums_lengths_lemma",
"FStar.Sequence.Base.index_into_build_lemma",
"FStar.Sequence.Base.build_increments_length_lemma",
"FStar.Sequence.Base.singleton_length_one_lemma",
"FStar.Sequence.Base.length_zero_implies_empty_lemma",
"FStar.Sequence.Base.length_of_empty_is_zero_lemma",
"Prims.l_True",
"Prims.squash",
"FStar.Sequence.Base.all_seq_facts",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let all_seq_facts_lemma () : Lemma (all_seq_facts u#a) =
| length_of_empty_is_zero_lemma u#a ();
length_zero_implies_empty_lemma u#a ();
singleton_length_one_lemma u#a ();
build_increments_length_lemma u#a ();
index_into_build_lemma u#a ();
append_sums_lengths_lemma u#a ();
index_into_singleton_lemma u#a ();
index_after_append_lemma u#a ();
update_maintains_length_lemma u#a ();
update_then_index_lemma u#a ();
contains_iff_exists_index_lemma u#a ();
empty_doesnt_contain_anything_lemma u#a ();
build_contains_equiv_lemma u#a ();
take_contains_equiv_exists_lemma u#a ();
drop_contains_equiv_exists_lemma u#a ();
equal_def_lemma u#a ();
extensionality_lemma u#a ();
is_prefix_def_lemma u#a ();
take_length_lemma u#a ();
index_into_take_lemma u#a ();
drop_length_lemma u#a ();
index_into_drop_lemma u#a ();
drop_index_offset_lemma u#a ();
append_then_take_or_drop_lemma u#a ();
take_commutes_with_in_range_update_lemma u#a ();
take_ignores_out_of_range_update_lemma u#a ();
drop_commutes_with_in_range_update_lemma u#a ();
drop_ignores_out_of_range_update_lemma u#a ();
drop_commutes_with_build_lemma u#a ();
rank_def_lemma u#a ();
element_ranks_less_lemma u#a ();
drop_ranks_less_lemma u#a ();
take_ranks_less_lemma u#a ();
append_take_drop_ranks_less_lemma u#a ();
drop_zero_lemma u#a ();
take_zero_lemma u#a ();
drop_then_drop_lemma u#a () | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_ranks_less_lemma | val drop_ranks_less_lemma: Prims.unit -> Lemma (drop_ranks_less_fact) | val drop_ranks_less_lemma: Prims.unit -> Lemma (drop_ranks_less_fact) | let drop_ranks_less_lemma () : Lemma (drop_ranks_less_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat).
0 < i && i <= length s ==> rank (drop s i) << rank s
with
introduce _ ==> _
with given_antecedent. (
drop_ranks_less_helper ty s i
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 672,
"start_col": 8,
"start_line": 665
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1)
private let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
)
#push-options "--z3rlimit 20"
private let rec take_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s
/\ length (take s n) = n)
(ensures take (update s i v) n == update (take s n) i v) =
match s with
| hd :: tl -> if i = 0 then () else (update_maintains_length_lemma() ; take_commutes_with_in_range_update_helper tl (i - 1) v (n - 1))
#pop-options
private let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (take s n) = n); // triggers take_length_fact
take_commutes_with_in_range_update_helper s i v n
)
private let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
take (update s i v) n == take s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
take_ignores_out_of_range_update_helper s i v n
)
#push-options "--fuel 2 --ifuel 1 --z3rlimit_factor 4"
private let rec drop_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s
/\ length (drop s n) = length s - n)
(ensures drop (update s i v) n ==
update (drop s n) (i - n) v) =
match s with
| hd :: tl ->
if n = 0
then ()
else (
update_maintains_length_lemma ();
drop_length_lemma ();
drop_commutes_with_in_range_update_helper tl (i - 1) v (n - 1)
)
#pop-options
private let drop_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
drop (update s i v) n == update (drop s n) (i - n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (drop s n) = length s - n); // triggers drop_length_fact
drop_commutes_with_in_range_update_helper s i v n
)
private let rec drop_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s)
(ensures drop (update s i v) n == drop s n) =
match s with
| hd :: tl -> if i = 0 then () else drop_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let drop_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
drop (update s i v) n == drop s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
drop_ignores_out_of_range_update_helper s i v n
)
private let rec drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) =
match s with
| [] ->
assert (append s [v] == [v]);
assert (n == 0);
()
| hd :: tl -> if n = 0 then () else drop_commutes_with_build_helper tl v (n - 1)
private let drop_commutes_with_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (n: nat).
n <= length s ==> drop (build s v) n == build (drop s n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (build s v) = 1 + length s); // triggers build_increments_length_fact
drop_commutes_with_build_helper s v n
)
private let rank_def_lemma () : Lemma (rank_def_fact) =
()
private let element_ranks_less_lemma () : Lemma (element_ranks_less_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat). i < length s ==> rank (index s i) << rank s
with
introduce _ ==> _
with given_antecedent. (
contains_iff_exists_index_lemma ();
assert (contains s (index s i));
FLT.memP_precedes (index s i) s
)
private let rec drop_ranks_less_helper (ty: Type) (s: list ty) (i: nat)
: Lemma (requires 0 < i && i <= length s)
(ensures drop s i << s) =
match s with
| [] -> ()
| hd :: tl -> if i = 1 then () else drop_ranks_less_helper ty tl (i - 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.drop_ranks_less_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.precedes",
"FStar.Sequence.Base.rank",
"FStar.Sequence.Base.drop",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.Sequence.Base.drop_ranks_less_helper",
"Prims.l_True",
"FStar.Sequence.Base.drop_ranks_less_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let drop_ranks_less_lemma () : Lemma (drop_ranks_less_fact) =
| introduce forall (ty: Type) (s: seq ty) (i: nat) . 0 < i && i <= length s ==>
rank (drop s i) << rank s
with introduce _ ==> _
with given_antecedent. (drop_ranks_less_helper ty s i) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_commutes_with_in_range_update_lemma | val drop_commutes_with_in_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) | val drop_commutes_with_in_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) | let drop_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
drop (update s i v) n == update (drop s n) (i - n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (drop s n) = length s - n); // triggers drop_length_fact
drop_commutes_with_in_range_update_helper s i v n
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 598,
"start_col": 8,
"start_line": 585
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1)
private let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
)
#push-options "--z3rlimit 20"
private let rec take_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s
/\ length (take s n) = n)
(ensures take (update s i v) n == update (take s n) i v) =
match s with
| hd :: tl -> if i = 0 then () else (update_maintains_length_lemma() ; take_commutes_with_in_range_update_helper tl (i - 1) v (n - 1))
#pop-options
private let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (take s n) = n); // triggers take_length_fact
take_commutes_with_in_range_update_helper s i v n
)
private let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
take (update s i v) n == take s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
take_ignores_out_of_range_update_helper s i v n
)
#push-options "--fuel 2 --ifuel 1 --z3rlimit_factor 4"
private let rec drop_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s
/\ length (drop s n) = length s - n)
(ensures drop (update s i v) n ==
update (drop s n) (i - n) v) =
match s with
| hd :: tl ->
if n = 0
then ()
else (
update_maintains_length_lemma ();
drop_length_lemma ();
drop_commutes_with_in_range_update_helper tl (i - 1) v (n - 1)
)
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(requires
FStar.Sequence.Base.update_maintains_length_fact /\ FStar.Sequence.Base.drop_length_fact)
(ensures FStar.Sequence.Base.drop_commutes_with_in_range_update_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.drop",
"FStar.Sequence.Base.update",
"Prims.op_Subtraction",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.Sequence.Base.drop_commutes_with_in_range_update_helper",
"Prims._assert",
"Prims.op_Equality",
"Prims.int",
"Prims.l_and",
"FStar.Sequence.Base.update_maintains_length_fact",
"FStar.Sequence.Base.drop_length_fact",
"FStar.Sequence.Base.drop_commutes_with_in_range_update_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let drop_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat) . n <= i && i < length s ==>
drop (update s i v) n == update (drop s n) (i - n) v
with introduce _ ==> _
with given_antecedent. (assert (length (update s i v) = length s);
assert (length (drop s n) = length s - n);
drop_commutes_with_in_range_update_helper s i v n) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_index_offset_lemma | val drop_index_offset_lemma: Prims.unit
-> Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) | val drop_index_offset_lemma: Prims.unit
-> Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) | let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 498,
"start_col": 8,
"start_line": 488
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma (requires FStar.Sequence.Base.drop_length_fact)
(ensures FStar.Sequence.Base.drop_index_offset_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.index",
"FStar.Sequence.Base.drop",
"Prims.op_Subtraction",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.Sequence.Base.index_into_drop_helper",
"Prims._assert",
"Prims.op_Equality",
"Prims.int",
"FStar.Sequence.Base.drop_length_fact",
"FStar.Sequence.Base.drop_index_offset_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (n: nat) (k: nat) . n <= k && k < length s ==>
index (drop s n) (k - n) == index s k
with introduce _ ==> _
with given_antecedent. (assert (length (drop s n) = length s - n);
index_into_drop_helper s n (k - n)) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.append_then_take_or_drop_helper | val append_then_take_or_drop_helper (#ty: Type) (s t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) | val append_then_take_or_drop_helper (#ty: Type) (s t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) | let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 60,
"end_line": 505,
"start_col": 8,
"start_line": 500
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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: Prims.list ty -> t: Prims.list ty -> n: Prims.nat
-> FStar.Pervasives.Lemma
(requires
n = FStar.Sequence.Base.length s /\
FStar.Sequence.Base.length (FStar.Sequence.Base.append s t) =
FStar.Sequence.Base.length s + FStar.Sequence.Base.length t)
(ensures
FStar.Sequence.Base.take (FStar.Sequence.Base.append s t) n == s /\
FStar.Sequence.Base.drop (FStar.Sequence.Base.append s t) n == t) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"FStar.Sequence.Base.append_then_take_or_drop_helper",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Sequence.Base.length",
"Prims.int",
"FStar.Sequence.Base.append",
"Prims.op_Addition",
"Prims.squash",
"Prims.eq2",
"FStar.Sequence.Base.take",
"FStar.Sequence.Base.drop",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec append_then_take_or_drop_helper (#ty: Type) (s t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
| match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_commutes_with_build_helper | val drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) | val drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) | let rec drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) =
match s with
| [] ->
assert (append s [v] == [v]);
assert (n == 0);
()
| hd :: tl -> if n = 0 then () else drop_commutes_with_build_helper tl v (n - 1) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 82,
"end_line": 630,
"start_col": 8,
"start_line": 622
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1)
private let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
)
#push-options "--z3rlimit 20"
private let rec take_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s
/\ length (take s n) = n)
(ensures take (update s i v) n == update (take s n) i v) =
match s with
| hd :: tl -> if i = 0 then () else (update_maintains_length_lemma() ; take_commutes_with_in_range_update_helper tl (i - 1) v (n - 1))
#pop-options
private let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (take s n) = n); // triggers take_length_fact
take_commutes_with_in_range_update_helper s i v n
)
private let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
take (update s i v) n == take s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
take_ignores_out_of_range_update_helper s i v n
)
#push-options "--fuel 2 --ifuel 1 --z3rlimit_factor 4"
private let rec drop_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s
/\ length (drop s n) = length s - n)
(ensures drop (update s i v) n ==
update (drop s n) (i - n) v) =
match s with
| hd :: tl ->
if n = 0
then ()
else (
update_maintains_length_lemma ();
drop_length_lemma ();
drop_commutes_with_in_range_update_helper tl (i - 1) v (n - 1)
)
#pop-options
private let drop_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
drop (update s i v) n == update (drop s n) (i - n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (drop s n) = length s - n); // triggers drop_length_fact
drop_commutes_with_in_range_update_helper s i v n
)
private let rec drop_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s)
(ensures drop (update s i v) n == drop s n) =
match s with
| hd :: tl -> if i = 0 then () else drop_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let drop_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
drop (update s i v) n == drop s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
drop_ignores_out_of_range_update_helper s i v n
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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: Prims.list ty -> v: ty -> n: Prims.nat
-> FStar.Pervasives.Lemma
(requires
n <= FStar.Sequence.Base.length s /\
FStar.Sequence.Base.length (FStar.Sequence.Base.append s [v]) =
1 + FStar.Sequence.Base.length s)
(ensures
FStar.Sequence.Base.drop (FStar.Sequence.Base.append s [v]) n ==
FStar.Sequence.Base.append (FStar.Sequence.Base.drop s n) [v]) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"FStar.Sequence.Base.append",
"Prims.Cons",
"Prims.Nil",
"Prims.op_Equality",
"Prims.bool",
"FStar.Sequence.Base.drop_commutes_with_build_helper",
"Prims.op_Subtraction",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.op_Addition",
"Prims.squash",
"FStar.Sequence.Base.seq",
"FStar.Sequence.Base.drop",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) =
| match s with
| [] ->
assert (append s [v] == [v]);
assert (n == 0);
()
| hd :: tl -> if n = 0 then () else drop_commutes_with_build_helper tl v (n - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_ignores_out_of_range_update_lemma | val take_ignores_out_of_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) | val take_ignores_out_of_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) | let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
take (update s i v) n == take s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
take_ignores_out_of_range_update_helper s i v n
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 564,
"start_col": 8,
"start_line": 552
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1)
private let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
)
#push-options "--z3rlimit 20"
private let rec take_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s
/\ length (take s n) = n)
(ensures take (update s i v) n == update (take s n) i v) =
match s with
| hd :: tl -> if i = 0 then () else (update_maintains_length_lemma() ; take_commutes_with_in_range_update_helper tl (i - 1) v (n - 1))
#pop-options
private let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (take s n) = n); // triggers take_length_fact
take_commutes_with_in_range_update_helper s i v n
)
private let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma (requires FStar.Sequence.Base.update_maintains_length_fact)
(ensures FStar.Sequence.Base.take_ignores_out_of_range_update_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.take",
"FStar.Sequence.Base.update",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.Sequence.Base.take_ignores_out_of_range_update_helper",
"Prims._assert",
"Prims.op_Equality",
"FStar.Sequence.Base.update_maintains_length_fact",
"FStar.Sequence.Base.take_ignores_out_of_range_update_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat) . n <= i && i < length s ==>
take (update s i v) n == take s n
with introduce _ ==> _
with given_antecedent. (assert (length (update s i v) = length s);
take_ignores_out_of_range_update_helper s i v n) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.append_take_drop_ranks_less_lemma | val append_take_drop_ranks_less_lemma: Prims.unit -> Lemma (append_take_drop_ranks_less_fact) | val append_take_drop_ranks_less_lemma: Prims.unit -> Lemma (append_take_drop_ranks_less_fact) | let append_take_drop_ranks_less_lemma () : Lemma (append_take_drop_ranks_less_fact) =
take_length_lemma ();
drop_length_lemma ();
append_sums_lengths_lemma () | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 680,
"start_col": 8,
"start_line": 677
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1)
private let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
)
#push-options "--z3rlimit 20"
private let rec take_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s
/\ length (take s n) = n)
(ensures take (update s i v) n == update (take s n) i v) =
match s with
| hd :: tl -> if i = 0 then () else (update_maintains_length_lemma() ; take_commutes_with_in_range_update_helper tl (i - 1) v (n - 1))
#pop-options
private let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (take s n) = n); // triggers take_length_fact
take_commutes_with_in_range_update_helper s i v n
)
private let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
take (update s i v) n == take s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
take_ignores_out_of_range_update_helper s i v n
)
#push-options "--fuel 2 --ifuel 1 --z3rlimit_factor 4"
private let rec drop_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s
/\ length (drop s n) = length s - n)
(ensures drop (update s i v) n ==
update (drop s n) (i - n) v) =
match s with
| hd :: tl ->
if n = 0
then ()
else (
update_maintains_length_lemma ();
drop_length_lemma ();
drop_commutes_with_in_range_update_helper tl (i - 1) v (n - 1)
)
#pop-options
private let drop_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
drop (update s i v) n == update (drop s n) (i - n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (drop s n) = length s - n); // triggers drop_length_fact
drop_commutes_with_in_range_update_helper s i v n
)
private let rec drop_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s)
(ensures drop (update s i v) n == drop s n) =
match s with
| hd :: tl -> if i = 0 then () else drop_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let drop_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
drop (update s i v) n == drop s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
drop_ignores_out_of_range_update_helper s i v n
)
private let rec drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) =
match s with
| [] ->
assert (append s [v] == [v]);
assert (n == 0);
()
| hd :: tl -> if n = 0 then () else drop_commutes_with_build_helper tl v (n - 1)
private let drop_commutes_with_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (n: nat).
n <= length s ==> drop (build s v) n == build (drop s n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (build s v) = 1 + length s); // triggers build_increments_length_fact
drop_commutes_with_build_helper s v n
)
private let rank_def_lemma () : Lemma (rank_def_fact) =
()
private let element_ranks_less_lemma () : Lemma (element_ranks_less_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat). i < length s ==> rank (index s i) << rank s
with
introduce _ ==> _
with given_antecedent. (
contains_iff_exists_index_lemma ();
assert (contains s (index s i));
FLT.memP_precedes (index s i) s
)
private let rec drop_ranks_less_helper (ty: Type) (s: list ty) (i: nat)
: Lemma (requires 0 < i && i <= length s)
(ensures drop s i << s) =
match s with
| [] -> ()
| hd :: tl -> if i = 1 then () else drop_ranks_less_helper ty tl (i - 1)
private let drop_ranks_less_lemma () : Lemma (drop_ranks_less_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat).
0 < i && i <= length s ==> rank (drop s i) << rank s
with
introduce _ ==> _
with given_antecedent. (
drop_ranks_less_helper ty s i
)
private let take_ranks_less_lemma () : Lemma (take_ranks_less_fact) =
take_length_lemma () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.append_take_drop_ranks_less_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Sequence.Base.append_sums_lengths_lemma",
"FStar.Sequence.Base.drop_length_lemma",
"FStar.Sequence.Base.take_length_lemma",
"Prims.l_True",
"Prims.squash",
"FStar.Sequence.Base.append_take_drop_ranks_less_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let append_take_drop_ranks_less_lemma () : Lemma (append_take_drop_ranks_less_fact) =
| take_length_lemma ();
drop_length_lemma ();
append_sums_lengths_lemma () | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_ranks_less_lemma | val take_ranks_less_lemma: Prims.unit -> Lemma (take_ranks_less_fact) | val take_ranks_less_lemma: Prims.unit -> Lemma (take_ranks_less_fact) | let take_ranks_less_lemma () : Lemma (take_ranks_less_fact) =
take_length_lemma () | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 675,
"start_col": 8,
"start_line": 674
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1)
private let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
)
#push-options "--z3rlimit 20"
private let rec take_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s
/\ length (take s n) = n)
(ensures take (update s i v) n == update (take s n) i v) =
match s with
| hd :: tl -> if i = 0 then () else (update_maintains_length_lemma() ; take_commutes_with_in_range_update_helper tl (i - 1) v (n - 1))
#pop-options
private let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (take s n) = n); // triggers take_length_fact
take_commutes_with_in_range_update_helper s i v n
)
private let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
take (update s i v) n == take s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
take_ignores_out_of_range_update_helper s i v n
)
#push-options "--fuel 2 --ifuel 1 --z3rlimit_factor 4"
private let rec drop_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s
/\ length (drop s n) = length s - n)
(ensures drop (update s i v) n ==
update (drop s n) (i - n) v) =
match s with
| hd :: tl ->
if n = 0
then ()
else (
update_maintains_length_lemma ();
drop_length_lemma ();
drop_commutes_with_in_range_update_helper tl (i - 1) v (n - 1)
)
#pop-options
private let drop_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
drop (update s i v) n == update (drop s n) (i - n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (drop s n) = length s - n); // triggers drop_length_fact
drop_commutes_with_in_range_update_helper s i v n
)
private let rec drop_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s)
(ensures drop (update s i v) n == drop s n) =
match s with
| hd :: tl -> if i = 0 then () else drop_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let drop_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
drop (update s i v) n == drop s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
drop_ignores_out_of_range_update_helper s i v n
)
private let rec drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) =
match s with
| [] ->
assert (append s [v] == [v]);
assert (n == 0);
()
| hd :: tl -> if n = 0 then () else drop_commutes_with_build_helper tl v (n - 1)
private let drop_commutes_with_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (n: nat).
n <= length s ==> drop (build s v) n == build (drop s n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (build s v) = 1 + length s); // triggers build_increments_length_fact
drop_commutes_with_build_helper s v n
)
private let rank_def_lemma () : Lemma (rank_def_fact) =
()
private let element_ranks_less_lemma () : Lemma (element_ranks_less_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat). i < length s ==> rank (index s i) << rank s
with
introduce _ ==> _
with given_antecedent. (
contains_iff_exists_index_lemma ();
assert (contains s (index s i));
FLT.memP_precedes (index s i) s
)
private let rec drop_ranks_less_helper (ty: Type) (s: list ty) (i: nat)
: Lemma (requires 0 < i && i <= length s)
(ensures drop s i << s) =
match s with
| [] -> ()
| hd :: tl -> if i = 1 then () else drop_ranks_less_helper ty tl (i - 1)
private let drop_ranks_less_lemma () : Lemma (drop_ranks_less_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat).
0 < i && i <= length s ==> rank (drop s i) << rank s
with
introduce _ ==> _
with given_antecedent. (
drop_ranks_less_helper ty s i
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit -> FStar.Pervasives.Lemma (ensures FStar.Sequence.Base.take_ranks_less_fact) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Sequence.Base.take_length_lemma",
"Prims.l_True",
"Prims.squash",
"FStar.Sequence.Base.take_ranks_less_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let take_ranks_less_lemma () : Lemma (take_ranks_less_fact) =
| take_length_lemma () | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.drop_ranks_less_helper | val drop_ranks_less_helper (ty: Type) (s: list ty) (i: nat)
: Lemma (requires 0 < i && i <= length s) (ensures drop s i << s) | val drop_ranks_less_helper (ty: Type) (s: list ty) (i: nat)
: Lemma (requires 0 < i && i <= length s) (ensures drop s i << s) | let rec drop_ranks_less_helper (ty: Type) (s: list ty) (i: nat)
: Lemma (requires 0 < i && i <= length s)
(ensures drop s i << s) =
match s with
| [] -> ()
| hd :: tl -> if i = 1 then () else drop_ranks_less_helper ty tl (i - 1) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 74,
"end_line": 663,
"start_col": 8,
"start_line": 658
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1)
private let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
)
#push-options "--z3rlimit 20"
private let rec take_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s
/\ length (take s n) = n)
(ensures take (update s i v) n == update (take s n) i v) =
match s with
| hd :: tl -> if i = 0 then () else (update_maintains_length_lemma() ; take_commutes_with_in_range_update_helper tl (i - 1) v (n - 1))
#pop-options
private let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (take s n) = n); // triggers take_length_fact
take_commutes_with_in_range_update_helper s i v n
)
private let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let take_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures take_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
take (update s i v) n == take s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
take_ignores_out_of_range_update_helper s i v n
)
#push-options "--fuel 2 --ifuel 1 --z3rlimit_factor 4"
private let rec drop_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s
/\ length (drop s n) = length s - n)
(ensures drop (update s i v) n ==
update (drop s n) (i - n) v) =
match s with
| hd :: tl ->
if n = 0
then ()
else (
update_maintains_length_lemma ();
drop_length_lemma ();
drop_commutes_with_in_range_update_helper tl (i - 1) v (n - 1)
)
#pop-options
private let drop_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ drop_length_fact u#a)
(ensures drop_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
n <= i && i < length s ==>
drop (update s i v) n == update (drop s n) (i - n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (drop s n) = length s - n); // triggers drop_length_fact
drop_commutes_with_in_range_update_helper s i v n
)
private let rec drop_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s)
(ensures drop (update s i v) n == drop s n) =
match s with
| hd :: tl -> if i = 0 then () else drop_ignores_out_of_range_update_helper tl (i - 1) v (n - 1)
private let drop_ignores_out_of_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a)
(ensures drop_ignores_out_of_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
drop (update s i v) n == drop s n
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
drop_ignores_out_of_range_update_helper s i v n
)
private let rec drop_commutes_with_build_helper (#ty: Type) (s: list ty) (v: ty) (n: nat)
: Lemma (requires n <= length s /\ length (append s [v]) = 1 + length s)
(ensures drop (append s [v]) n == append (drop s n) [v]) =
match s with
| [] ->
assert (append s [v] == [v]);
assert (n == 0);
()
| hd :: tl -> if n = 0 then () else drop_commutes_with_build_helper tl v (n - 1)
private let drop_commutes_with_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures drop_commutes_with_build_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (n: nat).
n <= length s ==> drop (build s v) n == build (drop s n) v
with
introduce _ ==> _
with given_antecedent. (
assert (length (build s v) = 1 + length s); // triggers build_increments_length_fact
drop_commutes_with_build_helper s v n
)
private let rank_def_lemma () : Lemma (rank_def_fact) =
()
private let element_ranks_less_lemma () : Lemma (element_ranks_less_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat). i < length s ==> rank (index s i) << rank s
with
introduce _ ==> _
with given_antecedent. (
contains_iff_exists_index_lemma ();
assert (contains s (index s i));
FLT.memP_precedes (index s i) s
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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 | ty: Type -> s: Prims.list ty -> i: Prims.nat
-> FStar.Pervasives.Lemma (requires 0 < i && i <= FStar.Sequence.Base.length s)
(ensures FStar.Sequence.Base.drop s i << s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Sequence.Base.drop_ranks_less_helper",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.squash",
"Prims.precedes",
"FStar.Sequence.Base.seq",
"FStar.Sequence.Base.drop",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec drop_ranks_less_helper (ty: Type) (s: list ty) (i: nat)
: Lemma (requires 0 < i && i <= length s) (ensures drop s i << s) =
| match s with
| [] -> ()
| hd :: tl -> if i = 1 then () else drop_ranks_less_helper ty tl (i - 1) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_commutes_with_in_range_update_lemma | val take_commutes_with_in_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) | val take_commutes_with_in_range_update_lemma: Prims.unit
-> Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) | let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (take s n) = n); // triggers take_length_fact
take_commutes_with_in_range_update_helper s i v n
) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 542,
"start_col": 8,
"start_line": 529
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1)
private let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
)
#push-options "--z3rlimit 20"
private let rec take_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s
/\ length (take s n) = n)
(ensures take (update s i v) n == update (take s n) i v) =
match s with
| hd :: tl -> if i = 0 then () else (update_maintains_length_lemma() ; take_commutes_with_in_range_update_helper tl (i - 1) v (n - 1))
#pop-options | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(requires
FStar.Sequence.Base.update_maintains_length_fact /\ FStar.Sequence.Base.take_length_fact)
(ensures FStar.Sequence.Base.take_commutes_with_in_range_update_fact ()) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"FStar.Sequence.Base.seq",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"FStar.Sequence.Base.length",
"Prims.eq2",
"FStar.Sequence.Base.take",
"FStar.Sequence.Base.update",
"FStar.Classical.Sugar.implies_intro",
"Prims.squash",
"FStar.Sequence.Base.take_commutes_with_in_range_update_helper",
"Prims._assert",
"Prims.op_Equality",
"Prims.l_and",
"FStar.Sequence.Base.update_maintains_length_fact",
"FStar.Sequence.Base.take_length_fact",
"FStar.Sequence.Base.take_commutes_with_in_range_update_fact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
| introduce forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat) . i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with introduce _ ==> _
with given_antecedent. (assert (length (update s i v) = length s);
assert (length (take s n) = n);
take_commutes_with_in_range_update_helper s i v n) | false |
FStar.Sequence.Base.fst | FStar.Sequence.Base.take_ignores_out_of_range_update_helper | val take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i /\ i < length s /\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) | val take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i /\ i < length s /\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) | let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i
/\ i < length s
/\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1) | {
"file_name": "ulib/experimental/FStar.Sequence.Base.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 98,
"end_line": 550,
"start_col": 8,
"start_line": 544
} | (*
Copyright 2008-2021 Jay Lorch, Rustan Leino, Alex Summers, Dan
Rosen, Nikhil Swamy, Microsoft Research, and contributors to
the Dafny Project
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a 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.
Includes material from the Dafny project
(https://github.com/dafny-lang/dafny) which carries this license
information:
Created 9 February 2008 by Rustan Leino.
Converted to Boogie 2 on 28 June 2008.
Edited sequence axioms 20 October 2009 by Alex Summers.
Modified 2014 by Dan Rosen.
Copyright (c) 2008-2014, Microsoft.
Copyright by the contributors to the Dafny Project
SPDX-License-Identifier: MIT
*)
(**
This module declares a type and functions used for modeling sequences
as they're modeled in Dafny. It also states and proves some properties
about sequences, and provides a lemma `all_seq_facts_lemma` one
can call to bring them into context. The properties are modeled after
those in the Dafny sequence axioms, with patterns for quantifiers
chosen as in those axioms.
@summary Type, functions, and properties of sequences
*)
module FStar.Sequence.Base
module FLT = FStar.List.Tot
/// Internally, we represent a sequence as a list.
type seq (ty: Type) = list ty
/// We represent the Dafny function `Seq#Length` with `length`:
///
/// function Seq#Length<T>(Seq T): int;
let length = FLT.length
/// We represent the Dafny function `Seq#Empty` with `empty`:
///
/// function Seq#Empty<T>(): Seq T;
let empty (#ty: Type) : seq ty = []
/// We represent the Dafny function `Seq#Singleton` with `singleton`:
///
/// function Seq#Singleton<T>(T): Seq T;
let singleton (#ty: Type) (v: ty) : seq ty =
[v]
/// We represent the Dafny function `Seq#Index` with `index`:
///
/// function Seq#Index<T>(Seq T, int): T;
let index (#ty: Type) (s: seq ty) (i: nat{i < length s}) : ty =
FLT.index s i
/// We represent the Dafny function `Seq#Build` with `build`:
///
/// function Seq#Build<T>(s: Seq T, val: T): Seq T;
let build (#ty: Type) (s: seq ty) (v: ty) : seq ty =
FLT.append s [v]
/// We represent the Dafny function `Seq#Append` with `append`:
///
/// function Seq#Append<T>(Seq T, Seq T): Seq T;
let append = FLT.append
/// We represent the Dafny function `Seq#Update` with `update`:
///
/// function Seq#Update<T>(Seq T, int, T): Seq T;
let update (#ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) : seq ty =
let s1, _, s2 = FLT.split3 s i in
append s1 (append [v] s2)
/// We represent the Dafny function `Seq#Contains` with `contains`:
///
/// function Seq#Contains<T>(Seq T, T): bool;
let contains (#ty: Type) (s: seq ty) (v: ty) : Type0 =
FLT.memP v s
/// We represent the Dafny function `Seq#Take` with `take`:
///
/// function Seq#Take<T>(s: Seq T, howMany: int): Seq T;
let take (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let result, _ = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Drop` with `drop`:
///
/// function Seq#Drop<T>(s: Seq T, howMany: int): Seq T;
let drop (#ty: Type) (s: seq ty) (howMany: nat{howMany <= length s}) : seq ty =
let _, result = FLT.splitAt howMany s in
result
/// We represent the Dafny function `Seq#Equal` with `equal`.
///
/// function Seq#Equal<T>(Seq T, Seq T): bool;
let equal (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 == length s1 /\
(forall j.{:pattern index s0 j \/ index s1 j}
0 <= j && j < length s0 ==> index s0 j == index s1 j)
/// Instead of representing the Dafny function `Seq#SameUntil`, which
/// is only ever used in Dafny to represent prefix relations, we
/// instead use `is_prefix`.
///
/// function Seq#SameUntil<T>(Seq T, Seq T, int): bool;
let is_prefix (#ty: Type) (s0: seq ty) (s1: seq ty) : Type0 =
length s0 <= length s1
/\ (forall (j: nat).{:pattern index s0 j \/ index s1 j}
j < length s0 ==> index s0 j == index s1 j)
/// We represent the Dafny function `Seq#Rank` with `rank`.
///
/// function Seq#Rank<T>(Seq T): int;
let rank (#ty: Type) (v: ty) = v
/// We now prove each of the facts that comprise `all_seq_facts`.
/// For fact `xxx_fact`, we prove it with `xxx_lemma`. Sometimes, that
/// requires a helper lemma, which we call `xxx_helper`. In some cases,
/// we need multiple helpers, so we suffix their names with integers.
private let length_of_empty_is_zero_lemma () : Lemma (length_of_empty_is_zero_fact) =
()
private let length_zero_implies_empty_lemma () : Lemma (length_zero_implies_empty_fact) =
()
private let singleton_length_one_lemma () : Lemma (singleton_length_one_fact) =
()
private let build_increments_length_lemma () : Lemma (build_increments_length_fact) =
introduce forall (ty: Type) (s: seq ty) (v: ty). length (build s v) = 1 + length s
with (
FLT.append_length s [v]
)
private let rec index_into_build_helper (#ty: Type) (s: list ty) (v: ty) (i: nat{i < length (append s [v])})
: Lemma (requires i <= length s)
(ensures index (append s [v]) i == (if i = length s then v else index s i)) =
FLT.append_length s [v];
match s with
| [] -> ()
| hd :: tl ->
if i = 0 then () else index_into_build_helper tl v (i - 1)
private let index_into_build_lemma ()
: Lemma (requires build_increments_length_fact u#a)
(ensures index_into_build_fact u#a ()) =
introduce forall (ty: Type) (s: seq ty) (v: ty) (i: nat{i < length (build s v)}).
(i = length s ==> index (build s v) i == v)
/\ (i <> length s ==> index (build s v) i == index s i)
with (
index_into_build_helper u#a s v i
)
private let append_sums_lengths_lemma () : Lemma (append_sums_lengths_fact) =
introduce forall (ty: Type) (s0: seq ty) (s1: seq ty). length (append s0 s1) = length s0 + length s1
with (
FLT.append_length s0 s1
)
private let index_into_singleton_lemma (_: squash (singleton_length_one_fact u#a)) : Lemma (index_into_singleton_fact u#a ()) =
()
private let rec index_after_append_helper (ty: Type) (s0: list ty) (s1: list ty) (n: nat)
: Lemma (requires n < length (append s0 s1) && length (append s0 s1) = length s0 + length s1)
(ensures index (append s0 s1) n == (if n < length s0 then index s0 n else index s1 (n - length s0))) =
match s0 with
| [] -> ()
| hd :: tl -> if n = 0 then () else index_after_append_helper ty tl s1 (n - 1)
private let index_after_append_lemma (_: squash (append_sums_lengths_fact u#a)) : Lemma (index_after_append_fact u#a ()) =
introduce
forall (ty: Type) (s0: seq ty) (s1: seq ty) (n: nat{n < length (append s0 s1)}).
(n < length s0 ==> index (append s0 s1) n == index s0 n)
/\ (length s0 <= n ==> index (append s0 s1) n == index s1 (n - length s0))
with (
index_after_append_helper ty s0 s1 n
)
private let rec lemma_splitAt_fst_length (#a:Type) (n:nat) (l:list a) :
Lemma
(requires (n <= length l))
(ensures (length (fst (FLT.splitAt n l)) = n)) =
match n, l with
| 0, _ -> ()
| _, [] -> ()
| _, _ :: l' -> lemma_splitAt_fst_length (n - 1) l'
private let update_maintains_length_helper (#ty: Type) (s: list ty) (i: nat{i < length s}) (v: ty)
: Lemma (length (update s i v) = length s) =
let s1, _, s2 = FLT.split3 s i in
lemma_splitAt_fst_length i s;
FLT.lemma_splitAt_snd_length i s;
FLT.append_length [v] s2;
FLT.append_length s1 (append [v] s2)
private let update_maintains_length_lemma () : Lemma (update_maintains_length_fact) =
introduce forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty).
length (update s i v) = length s
with (
update_maintains_length_helper s i v
)
private let rec update_then_index_helper
(#ty: Type)
(s: list ty)
(i: nat{i < length s})
(v: ty)
(n: nat{n < length (update s i v)})
: Lemma (requires n < length s)
(ensures index (update s i v) n == (if i = n then v else index s n)) =
match s with
| hd :: tl ->
if i = 0 || n = 0 then ()
else update_then_index_helper tl (i - 1) v (n - 1)
private let update_then_index_lemma () : Lemma (update_then_index_fact) =
update_maintains_length_lemma ();
introduce
forall (ty: Type) (s: seq ty) (i: nat{i < length s}) (v: ty) (n: nat{n < length (update s i v)}).
n < length s ==>
(i = n ==> index (update s i v) n == v)
/\ (i <> n ==> index (update s i v) n == index s n)
with
introduce _ ==> _
with given_antecedent. (
update_then_index_helper s i v n
)
private let contains_iff_exists_index_lemma () : Lemma (contains_iff_exists_index_fact) =
introduce
forall (ty: Type) (s: seq ty) (x: ty).
contains s x <==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with (
introduce contains s x ==> (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x)
with given_antecedent. (
introduce exists (i: nat). i < length s /\ index s i == x
with (FLT.index_of s x) and ()
);
introduce (exists (i: nat).{:pattern index s i} i < length s /\ index s i == x) ==> contains s x
with given_antecedent. (
eliminate exists (i: nat). i < length s /\ index s i == x
returns _
with _. FLT.lemma_index_memP s i
)
)
private let empty_doesnt_contain_anything_lemma () : Lemma (empty_doesnt_contain_anything_fact) =
()
private let rec build_contains_equiv_helper (ty: Type) (s: list ty) (v: ty) (x: ty)
: Lemma (FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)) =
match s with
| [] -> ()
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (append s [v]) <==> (v == x \/ FLT.memP x s)
with _. ()
and _. build_contains_equiv_helper ty tl v x
private let build_contains_equiv_lemma () : Lemma (build_contains_equiv_fact) =
introduce
forall (ty: Type) (s: seq ty) (v: ty) (x: ty).
contains (build s v) x <==> (v == x \/ contains s x)
with (
build_contains_equiv_helper ty s v x
)
private let rec take_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (take s n))
(ensures (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with case_x_eq_hd.
assert(index s 0 == x)
and case_x_ne_hd. (
take_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). i_tl < n - 1 /\ i_tl < length tl /\ index tl i_tl == x
returns exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x
with _.
introduce exists (i: nat). i < n /\ i < length s /\ index s i == x
with (i_tl + 1)
and ())
private let rec take_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (i < n /\ i < length s /\ index s i == x))
(ensures FLT.memP x (take s n)) =
match s with
| hd :: tl ->
eliminate x == hd \/ ~(x == hd)
returns FLT.memP x (take s n)
with case_x_eq_hd. ()
and case_x_ne_hd. take_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1)
private let take_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (take s n) <==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (take s n) ==>
(exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x)
with given_antecedent. (take_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} i < n /\ i < length s /\ index s i == x) ==>
FLT.memP x (take s n)
with given_antecedent. (
eliminate exists (i: nat). i < n /\ i < length s /\ index s i == x
returns _
with _. take_contains_equiv_exists_helper2 ty s n x i
)
private let take_contains_equiv_exists_lemma () : Lemma (take_contains_equiv_exists_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (take s n) x <==>
(exists (i: nat). i < n /\ i < length s /\ index s i == x)
with (
take_contains_equiv_exists_helper3 ty s n x
)
#push-options "--z3rlimit_factor 10 --fuel 1 --ifuel 1"
private let rec drop_contains_equiv_exists_helper1 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (requires FLT.memP x (drop s n))
(ensures (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x
with case_n_eq_0. (
eliminate x == hd \/ ~(x == hd)
returns _
with _. assert(index s 0 == x)
and _. (
drop_contains_equiv_exists_helper1 ty tl n x;
eliminate exists (i_tl: nat). (n <= i_tl /\ i_tl < length tl /\ index tl i_tl == x)
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ()
))
and case_n_ne_0. (
drop_contains_equiv_exists_helper1 ty tl (n - 1) x;
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _. introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
#pop-options
private let rec drop_contains_equiv_exists_helper2 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty) (i: nat)
: Lemma (requires (n <= i /\ i < length s /\ index s i == x))
(ensures FLT.memP x (drop s n)) =
match s with
| hd :: tl ->
eliminate n == 0 \/ n <> 0
returns FLT.memP x (drop s n)
with _. FLT.lemma_index_memP s i
and _. (
drop_contains_equiv_exists_helper2 ty tl (n - 1) x (i - 1);
eliminate exists (i_tl: nat). n - 1 <= i_tl /\ i_tl < length tl /\ index tl i_tl == x
returns _
with _.
introduce exists i. n <= i /\ i < length s /\ index s i == x with (i_tl + 1) and ())
private let drop_contains_equiv_exists_helper3 (ty: Type) (s: list ty) (n: nat{n <= length s}) (x: ty)
: Lemma (FLT.memP x (drop s n) <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)) =
introduce FLT.memP x (drop s n) ==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with given_antecedent. (
drop_contains_equiv_exists_helper1 ty s n x);
introduce (exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x) ==>
FLT.memP x (drop s n)
with given_antecedent. (
eliminate exists (i: nat). n <= i /\ i < length s /\ index s i == x
returns _
with _. drop_contains_equiv_exists_helper2 ty s n x i
)
private let drop_contains_equiv_exists_lemma () : Lemma (drop_contains_equiv_exists_fact) =
introduce
forall (ty: Type) (s: seq ty) (n: nat{n <= length s}) (x: ty).
contains (drop s n) x <==>
(exists (i: nat).{:pattern index s i} n <= i /\ i < length s /\ index s i == x)
with (
drop_contains_equiv_exists_helper3 ty s n x;
assert (FLT.memP x (drop s n) <==>
(exists (i: nat). n <= i /\ i < length s /\ index s i == x))
)
private let equal_def_lemma () : Lemma (equal_def_fact) =
()
private let extensionality_lemma () : Lemma (extensionality_fact) =
introduce forall (ty: Type) (a: seq ty) (b: seq ty). equal a b ==> a == b
with
introduce _ ==> _
with given_antecedent. (
introduce forall (i: nat) . i < length a ==> index a i == index b i
with
introduce _ ==> _
with given_antecedent. (
assert (index a i == index b i) // needed to trigger
);
FStar.List.Tot.Properties.index_extensionality a b
)
private let is_prefix_def_lemma () : Lemma (is_prefix_def_fact) =
()
private let take_length_lemma () : Lemma (take_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (take s n) = n
with
introduce _ ==> _
with given_antecedent. (
lemma_splitAt_fst_length n s
)
private let rec index_into_take_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < n && n <= length s /\ length (take s n) = n)
(ensures index (take s n) j == index s j) =
match s with
| hd :: tl -> if j = 0 || n = 0 then () else index_into_take_helper tl (n - 1) (j - 1)
private let index_into_take_lemma ()
: Lemma (requires take_length_fact u#a) (ensures index_into_take_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < n && n <= length s ==> index (take s n) j == index s j
with
introduce _ ==> _
with given_antecedent. (
assert (length (take s n) == n); // triggers take_length_fact
index_into_take_helper s n j
)
private let drop_length_lemma () : Lemma (drop_length_fact) =
introduce forall (ty: Type) (s: seq ty) (n: nat).
n <= length s ==> length (drop s n) = length s - n
with
introduce _ ==> _
with given_antecedent. (
FLT.lemma_splitAt_snd_length n s
)
private let rec index_into_drop_helper (#ty: Type) (s: list ty) (n: nat) (j: nat)
: Lemma (requires j < length s - n /\ length (drop s n) = length s - n)
(ensures index (drop s n) j == index s (j + n)) =
match s with
| hd :: tl -> if n = 0 then () else index_into_drop_helper tl (n - 1) j
private let index_into_drop_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures index_into_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (j: nat).
j < length s - n ==> index (drop s n) j == index s (j + n)
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n j
)
private let drop_index_offset_lemma ()
: Lemma (requires drop_length_fact u#a) (ensures drop_index_offset_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (n: nat) (k: nat).
n <= k && k < length s ==> index (drop s n) (k - n) == index s k
with
introduce _ ==> _
with given_antecedent. (
assert (length (drop s n) = length s - n); // triggers drop_length_fact
index_into_drop_helper s n (k - n)
)
private let rec append_then_take_or_drop_helper (#ty: Type) (s: list ty) (t: list ty) (n: nat)
: Lemma (requires n = length s /\ length (append s t) = length s + length t)
(ensures take (append s t) n == s /\ drop (append s t) n == t) =
match s with
| [] -> ()
| hd :: tl -> append_then_take_or_drop_helper tl t (n - 1)
private let append_then_take_or_drop_lemma ()
: Lemma (requires append_sums_lengths_fact u#a) (ensures append_then_take_or_drop_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (t: seq ty) (n: nat).
n = length s ==> take (append s t) n == s /\ drop (append s t) n == t
with
introduce _ ==> _
with given_antecedent. (
append_then_take_or_drop_helper s t n
)
#push-options "--z3rlimit 20"
private let rec take_commutes_with_in_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires i < n
/\ n <= length s
/\ length (update s i v) = length s
/\ length (take s n) = n)
(ensures take (update s i v) n == update (take s n) i v) =
match s with
| hd :: tl -> if i = 0 then () else (update_maintains_length_lemma() ; take_commutes_with_in_range_update_helper tl (i - 1) v (n - 1))
#pop-options
private let take_commutes_with_in_range_update_lemma ()
: Lemma (requires update_maintains_length_fact u#a /\ take_length_fact u#a)
(ensures take_commutes_with_in_range_update_fact u#a ()) =
introduce
forall (ty: Type) (s: seq ty) (i: nat) (v: ty) (n: nat).
i < n && n <= length s ==>
take (update s i v) n == update (take s n) i v
with
introduce _ ==> _
with given_antecedent. (
assert (length (update s i v) = length s); // triggers update_maintains_length_fact
assert (length (take s n) = n); // triggers take_length_fact
take_commutes_with_in_range_update_helper s i v n
) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.Sugar.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Sequence.Base.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "FLT"
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Sequence",
"short_module": null
},
{
"abbrev": 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: Prims.list ty -> i: Prims.nat -> v: ty -> n: Prims.nat
-> FStar.Pervasives.Lemma
(requires
n <= i /\ i < FStar.Sequence.Base.length s /\
FStar.Sequence.Base.length (FStar.Sequence.Base.update s i v) = FStar.Sequence.Base.length s
)
(ensures
FStar.Sequence.Base.take (FStar.Sequence.Base.update s i v) n ==
FStar.Sequence.Base.take s n) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Sequence.Base.take_ignores_out_of_range_update_helper",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"FStar.Sequence.Base.length",
"FStar.Sequence.Base.update",
"Prims.squash",
"Prims.eq2",
"FStar.Sequence.Base.seq",
"FStar.Sequence.Base.take",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec take_ignores_out_of_range_update_helper (#ty: Type) (s: list ty) (i: nat) (v: ty) (n: nat)
: Lemma (requires n <= i /\ i < length s /\ length (update s i v) = length s)
(ensures take (update s i v) n == take s n) =
| match s with
| hd :: tl -> if n = 0 then () else take_ignores_out_of_range_update_helper tl (i - 1) v (n - 1) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.