| import OAI.Computability.FourierTransform.ProductMatrix |
|
|
| namespace OAI |
|
|
| /-! Binary orthonormal bases and masks for the fixed saving. -/ |
|
|
| namespace PowerSaving.Binary |
| open Finset Matrix |
|
|
| abbrev F := ZMod 2 |
| abbrev Space (α : Type*) := α → F |
|
|
| lemma bit_cases (x : F) : x=0 ∨ x=1 := by |
| fin_cases x |
| · left; rfl |
| · right; rfl |
|
|
| @[simp] theorem cancel (x : F) : x+x=0 := by |
| rcases bit_cases x with rfl | rfl <;> decide |
|
|
| @[simp] theorem binary_cancel {α : Type*} (x : Space α) : x+x=0 := by ext; exact cancel _ |
|
|
| section Dot |
| variable {α : Type*} [Fintype α] |
|
|
| def dot (x y : Space α) := ∑ i : α, x i * y i |
|
|
| theorem dot_symm (x y : Space α) : dot x y = dot y x := by simp [dot, mul_comm] |
|
|
| @[simp] theorem dot_add_left (x y z : Space α) : |
| dot (x+y) z = dot x z + dot y z := by simp [dot, add_mul, sum_add_distrib] |
|
|
| @[simp] theorem dot_add_right (x y z : Space α) : |
| dot x (y+z) = dot x y + dot x z := by simp [dot, mul_add, sum_add_distrib] |
|
|
| @[simp] theorem dot_smul_left (a : F) (x y : Space α) : |
| dot (a • x) y = a * dot x y := by simp [dot, mul_sum, mul_assoc] |
| @[simp] theorem dot_smul_right (a : F) (x y : Space α) : |
| dot x (a • y) = a * dot x y := by rw [dot_symm, dot_smul_left, dot_symm] |
|
|
| @[simp] theorem dot_zero_left (x : Space α) : dot 0 x=0 := by simp [dot] |
|
|
| @[simp] theorem dot_zero_right (x : Space α) : dot x 0=0 := by simp [dot] |
|
|
| theorem dot_sum {β : Type*} (x : Space α) (s : Finset β) (f : β → Space α) : |
| dot x (∑ j ∈ s, f j) = ∑ j ∈ s, dot x (f j) := by |
| classical |
| induction s using Finset.induction with |
| | empty => simp |
| | insert i s h ih => simp [h, ih] |
|
|
| variable [DecidableEq α] |
|
|
| def eu (i : α) : Space α := fun j => if i=j then 1 else 0 |
|
|
| @[simp] theorem dot_eu_left (x : Space α) (i : α) : dot (eu i) x = x i := by |
| simp [dot, eu, ite_mul] |
| @[simp] theorem dot_eu_right (x : Space α) (i : α) : dot x (eu i) = x i := by |
| rw [dot_symm]; simp |
|
|
| end Dot |
|
|
| / |
| structure OBase (α : Type*) [Fintype α] [DecidableEq α] where |
| v : α → Space α |
| rows : ∀ i j, dot (v i) (v j) = if i=j then 1 else 0 |
|
|
| namespace OBase |
| variable {α : Type*} [Fintype α] [DecidableEq α] |
|
|
| @[simp] theorem self (A : OBase α) (i : α) : dot (A.v i) (A.v i)=1 := by |
| simp [A.rows] |
|
|
| theorem nz (A : OBase α) (i : α) : A.v i ≠ 0 := by |
| intro h |
| have := A.self i |
| simp [h] at this |
|
|
| / |
| theorem cols (A : OBase α) (i j : α) : |
| ∑ k, A.v k i * A.v k j = if i=j then 1 else 0 := by |
| let M : Matrix α α F := Matrix.of A.v |
| have h : M * Mᵀ = 1 := by |
| ext i j |
| simpa [M, Matrix.mul_apply, one_apply, dot] using A.rows i j |
| have g : Mᵀ * M = 1 := mul_eq_one_comm.mp h |
| simpa [M, Matrix.mul_apply, one_apply] using congr_fun (congr_fun g i) j |
|
|
| def canonical (α : Type*) [Fintype α] [DecidableEq α] : OBase α := |
| ⟨eu, fun i j => by simp [eu]⟩ |
|
|
| def mat (A : OBase α) (s : Finset α) : Matrix α α F := |
| fun i j => ∑ k ∈ s, A.v k i * A.v k j |
|
|
| @[simp] theorem mat_univ (A : OBase α) : A.mat univ = 1 := by |
| ext i j |
| simpa only [mat, one_apply] using A.cols i j |
|
|
| theorem mat_sub (A : OBase α) (s t : Finset α) (h : t ⊆ s) : |
| A.mat (s \ t) = A.mat s - A.mat t := by |
| ext i j |
| simpa [mat, eq_sub_iff_add_eq] using |
| Finset.sum_sdiff h (f:=fun k => A.v k i * A.v k j) |
|
|
| / |
| def proj (A : OBase α) (s : Finset α) (x : Space α) : Space α := |
| ∑ k ∈ s, dot (A.v k) x • A.v k |
|
|
| theorem proj_apply (A : OBase α) (s : Finset α) (x : Space α) (i : α) : |
| A.proj s x i = ∑ j, A.mat s i j*x j := by |
| simp only [mat, proj, Finset.sum_apply, dot, sum_mul, Pi.smul_apply, smul_eq_mul] |
| rw [sum_comm] |
| apply Finset.sum_congr rfl |
| intro j hj |
| apply Finset.sum_congr rfl |
| intro k hk |
| ac_rfl |
|
|
| theorem proj_congr (A B : OBase α) (s t : Finset α) (h : A.mat s = B.mat t) : |
| A.proj s = B.proj t := by |
| funext x i; rw [proj_apply, h, ← proj_apply] |
|
|
| @[simp] theorem proj_univ (A : OBase α) (x : Space α) : A.proj univ x = x := by |
| ext i; simp [proj_apply, one_apply, ite_mul] |
|
|
| theorem dot_proj_omit (A : OBase α) {s : Finset α} {i : α} (x : Space α) (hi : i ∉ s) : |
| dot (A.v i) (A.proj s x) = 0 := by |
| rw [proj, dot_sum] |
| apply sum_eq_zero |
| intro j hj |
| have h : i ≠ j := by intro hh; exact hi (hh ▸ hj) |
| simp [A.rows, h] |
|
|
| section Adapt |
|
|
| / |
| def tv (w x : Space α) := x + dot w x • w |
|
|
| omit [DecidableEq α] in |
| theorem tv_isom (w x y : Space α) (h : dot w w = 0) : |
| dot (tv w x) (tv w y) = dot x y := by |
| simp only [tv, dot_add_right, dot_add_left, dot_smul_right, dot_smul_left, h, |
| mul_zero, add_zero] |
| rw [dot_symm x w, mul_comm (dot w y), add_assoc, cancel, add_zero] |
|
|
| def acted (A : OBase α) (w : Space α) (h : dot w w=0) : OBase α := |
| ⟨fun i => tv w (A.v i), fun i j => by rw [tv_isom _ _ _ h]; apply A.rows⟩ |
|
|
| def adapt (A : OBase α) (i : α) (t : Space α) (h1 : dot t t=1) |
| (h2 : dot t (A.v i) = 0) : OBase α := |
| acted A (t + A.v i) (by simp [h1, h2, dot_symm (A.v i) t]) |
|
|
| theorem adapt_pivot (A : OBase α) (i : α) (t : Space α) |
| (h1 : dot t t=1) (h2 : dot t (A.v i) = 0) : |
| (adapt A i t h1 h2).v i = t := by |
| simp only [adapt, acted, tv, dot_add_left, h2, A.self, zero_add, one_smul] |
| rw [add_comm t, ← add_assoc, binary_cancel, zero_add] |
|
|
| theorem adapt_other (A : OBase α) (i j : α) (t : Space α) (hi : i≠j) |
| (h1 : dot t t=1) (h2 : dot t (A.v i)=0) (h3 : dot t (A.v j)=0) : |
| (adapt A i t h1 h2).v j = A.v j := by simp [adapt, acted, tv, A.rows, hi, h3] |
|
|
| end Adapt |
|
|
| section Tensor |
| variable {J H : Type*} [Fintype J] [DecidableEq J] [Fintype H] [DecidableEq H] |
|
|
| def pure (A : J → OBase H) (k : J → H) : Space (J → H) := |
| fun l => ∏ j, (A j).v (k j) (l j) |
|
|
| def tensor (A : J → OBase H) : OBase (J → H) where |
| v := pure A |
| rows := fun x y => by |
| classical |
| simp only [pure, dot, ← prod_mul_distrib] |
| rw [← Fintype.prod_sum (fun j l => (A j).v (x j) l * (A j).v (y j) l)] |
| have hh (j : J) : ∑ l, ((A j).v (x j) l * (A j).v (y j) l) = |
| if x j=y j then 1 else 0 := (A j).rows (x j) (y j) |
| simpa only [hh] using |
| (show ∏ j, (∑ l, ((A j).v (x j) l * (A j).v (y j) l)) = _ by |
| simp only [hh] |
| apply prod_delta) |
|
|
| theorem mat_rect (A : J → OBase H) (s : J → Finset H) : |
| (tensor A).mat (Fintype.piFinset s) = digitProd (fun j => (A j).mat (s j)) := by |
| ext x y |
| simp only [digitProd_apply, mat, tensor, pure, ← prod_mul_distrib] |
| exact (prod_univ_sum s (fun j l => (A j).v l (x j) * (A j).v l (y j))).symm |
|
|
| end Tensor |
| end OBase |
|
|
| end PowerSaving.Binary |
|
|
| end OAI |
|
|
