| import OAI.Computability.FourierCircuit.LinearDAG |
|
|
| namespace OAI |
|
|
| section |
| /-! Exact finite tensor and disjoint-block constructions for the triangular |
| monotonicity experiment in 05-corners:130–201. -/ |
| namespace ExactFourier |
| open scoped Kronecker BigOperators |
| namespace TensorTools |
|
|
| variable {ι κ τ : Type} [Fintype ι] [Fintype κ] [Fintype τ] |
| [DecidableEq ι] [DecidableEq κ] [DecidableEq τ] |
| |
| theorem unit_reindex (e : ι ≃ κ) (A : Matrix ι ι ℂ) (hA : IsUnit A) : |
| IsUnit (Matrix.reindex e e A) := |
| hA.map (Matrix.reindexAlgEquiv ℂ ℂ e).toMonoidHom |
|
|
| theorem unit_tensor (A : Matrix ι ι ℂ) (B : Matrix κ κ ℂ) |
| (hA : IsUnit A) (hB : IsUnit B) : IsUnit (A ⊗ₖ B) := by |
| apply (Matrix.isUnit_iff_isUnit_det _).mpr |
| rw [Matrix.det_kronecker] |
| exact ((Matrix.isUnit_iff_isUnit_det _).mp hA).pow _ |>.mul |
| (((Matrix.isUnit_iff_isUnit_det _).mp hB).pow _) |
|
|
| def middleEquiv : (ι ⊕ κ) ⊕ τ ≃ (ι ⊕ τ) ⊕ κ where |
| toFun := Sum.elim (Sum.elim (Sum.inl ∘ Sum.inl) Sum.inr) (Sum.inl ∘ Sum.inr) |
| invFun := Sum.elim (Sum.elim (Sum.inl ∘ Sum.inl) Sum.inr) (Sum.inl ∘ Sum.inr) |
| left_inv := by rintro ((i|k)|t) <;> rfl |
| right_inv := by rintro ((i|t)|k) <;> rfl |
| |
| theorem pad_middle |
| {ι : Type} {κ : Type} {τ : Type} [Fintype ι] [Fintype κ] [Fintype τ] [DecidableEq ι] [DecidableEq κ] [DecidableEq τ] (A : Matrix ι ι ℂ) (E : Matrix ι κ ℂ) (Y : Matrix κ κ ℂ) : |
| Matrix.reindex (middleEquiv (τ := τ)) middleEquiv |
| (Matrix.fromBlocks (Matrix.fromBlocks A E 0 Y) 0 0 (1 : Matrix τ τ ℂ)) = |
| Matrix.fromBlocks (Matrix.fromBlocks A 0 0 (1 : Matrix τ τ ℂ)) |
| (Matrix.fromRows E 0) 0 Y := by |
| ext i j |
| rcases i with (i|t)|k <;> rcases j with (j|t')|k' <;> |
| simp [Matrix.reindex_apply, middleEquiv, Matrix.fromBlocks, Matrix.fromRows, Sum.elim, Matrix.one_apply] |
| |
| theorem pad_front |
| {ι : Type} {κ : Type} {τ : Type} [Fintype ι] [Fintype κ] [Fintype τ] [DecidableEq ι] [DecidableEq κ] [DecidableEq τ] (B : Matrix τ τ ℂ) (F : Matrix τ κ ℂ) (Z : Matrix κ κ ℂ) : |
| Matrix.reindex (Equiv.sumAssoc ι τ κ).symm (Equiv.sumAssoc ι τ κ).symm |
| (Matrix.fromBlocks (1 : Matrix ι ι ℂ) 0 0 (Matrix.fromBlocks B F 0 Z)) = |
| Matrix.fromBlocks (Matrix.fromBlocks (1 : Matrix ι ι ℂ) 0 0 B) |
| (Matrix.fromRows 0 F) 0 Z := by |
| ext i j |
| rcases i with (i|t)|k <;> rcases j with (j|t')|k' <;> |
| simp [Matrix.reindex_apply, Matrix.fromBlocks, Matrix.fromRows, Sum.elim, Matrix.one_apply] |
| |
| theorem join_mul |
| {ι : Type} {κ : Type} {τ : Type} [Fintype ι] [Fintype κ] [Fintype τ] [DecidableEq ι] [DecidableEq κ] [DecidableEq τ] (A : Matrix ι ι ℂ) (B : Matrix τ τ ℂ) |
| (E : Matrix ι κ ℂ) (F : Matrix τ κ ℂ) (Y Z : Matrix κ κ ℂ) : |
| Matrix.fromBlocks (Matrix.fromBlocks (1 : Matrix ι ι ℂ) 0 0 B) |
| (Matrix.fromRows 0 F) 0 Z * |
| Matrix.fromBlocks (Matrix.fromBlocks A 0 0 (1 : Matrix τ τ ℂ)) |
| (Matrix.fromRows E 0) 0 Y = |
| Matrix.fromBlocks (Matrix.fromBlocks A 0 0 B) |
| (Matrix.fromRows E (F * Y)) 0 (Z * Y) := by |
| simp only [Matrix.fromBlocks_multiply, Matrix.mul_zero, Matrix.zero_mul, add_zero, |
| zero_add, Matrix.one_mul, Matrix.mul_one] |
| congr 1 |
| ext i j |
| rcases i with i|t <;> |
| simp [Matrix.mul_apply, Fintype.sum_sum_type, Matrix.fromBlocks, Matrix.fromRows, Sum.elim, Matrix.one_apply] |
| |
| theorem price_join (p : MatrixPrice) (A : Matrix ι ι ℂ) (B : Matrix τ τ ℂ) |
| (E : Matrix ι κ ℂ) (F : Matrix τ κ ℂ) (Y Z : Matrix κ κ ℂ) |
| (hA : IsUnit A) (hB : IsUnit B) (hY : IsUnit Y) (hZ : IsUnit Z) : |
| p.value (Matrix.fromBlocks (Matrix.fromBlocks A 0 0 B) |
| (Matrix.fromRows E (F * Y)) 0 (Z * Y)) ≤ |
| p.value (Matrix.fromBlocks A E 0 Y) + p.value (Matrix.fromBlocks B F 0 Z) := by |
| have hT : IsUnit (Matrix.fromBlocks A E 0 Y) := |
| Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨hA,hY⟩ |
| have hU : IsUnit (Matrix.fromBlocks B F 0 Z) := |
| Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨hB,hZ⟩ |
| have hT' : IsUnit (Matrix.fromBlocks (Matrix.fromBlocks A E 0 Y) 0 0 (1 : Matrix τ τ ℂ)) := |
| Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨hT,isUnit_one⟩ |
| have hU' : IsUnit (Matrix.fromBlocks (1 : Matrix ι ι ℂ) 0 0 (Matrix.fromBlocks B F 0 Z)) := |
| Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨isUnit_one,hU⟩ |
| rw [← join_mul, ← pad_middle, ← pad_front] |
| calc |
| _ ≤ _ := p.mul_le _ _ (unit_reindex _ _ hU') (unit_reindex _ _ hT') |
| _ = _ := by rw [p.reindex _ _ hU', p.reindex _ _ hT', |
| p.directSum _ _ isUnit_one hU, p.identity_pad _ hT, p.one]; ring |
| |
| end TensorTools |
| end ExactFourier |
| |
| end |
| |
| section |
| /-! Two cell programs sharing only their persistent state space. Unlike the |
| triangular experiment, no invertibility of the state block is assumed. -/ |
| namespace ExactFourier |
| open TensorTools |
| namespace CellJoin |
| variable {α β γ : Type} [Fintype α] [Fintype β] [Fintype γ] |
| [DecidableEq α] [DecidableEq β] [DecidableEq γ] |
|
|
| abbrev join (X : Matrix (α ⊕ β) (α ⊕ β) ℂ) (Y : Matrix (γ ⊕ β) (γ ⊕ β) ℂ) : |
| Matrix ((α ⊕ γ) ⊕ β) ((α ⊕ γ) ⊕ β) ℂ := |
| Matrix.fromBlocks |
| (Matrix.fromBlocks X.toBlocks₁₁ 0 (Y.toBlocks₁₂ * X.toBlocks₂₁) Y.toBlocks₁₁) |
| (Matrix.fromRows X.toBlocks₁₂ (Y.toBlocks₁₂ * X.toBlocks₂₂)) |
| (Matrix.fromCols (Y.toBlocks₂₂ * X.toBlocks₂₁) Y.toBlocks₂₁) |
| (Y.toBlocks₂₂ * X.toBlocks₂₂) |
|
|
| theorem join_eq |
| {α : Type} {β : Type} {γ : Type} [Fintype α] [Fintype β] [Fintype γ] [DecidableEq α] [DecidableEq β] [DecidableEq γ] (X : Matrix (α ⊕ β) (α ⊕ β) ℂ) (Y : Matrix (γ ⊕ β) (γ ⊕ β) ℂ) : |
| join X Y = |
| Matrix.reindex (Equiv.sumAssoc α γ β).symm (Equiv.sumAssoc α γ β).symm |
| (Matrix.fromBlocks (1 : Matrix α α ℂ) 0 0 Y) * |
| Matrix.reindex (middleEquiv (ι := α) (κ := β) (τ := γ)) middleEquiv |
| (Matrix.fromBlocks X 0 0 (1 : Matrix γ γ ℂ)) := by |
| have hX : Matrix.reindex (middleEquiv (ι := α) (κ := β) (τ := γ)) middleEquiv |
| (Matrix.fromBlocks X 0 0 (1 : Matrix γ γ ℂ)) = |
| Matrix.fromBlocks (Matrix.fromBlocks X.toBlocks₁₁ 0 0 1) |
| (Matrix.fromRows X.toBlocks₁₂ 0) (Matrix.fromCols X.toBlocks₂₁ 0) X.toBlocks₂₂ := by |
| ext i j |
| rcases i with (a|c)|b <;> rcases j with (a'|c')|b' <;> |
| simp [Matrix.reindex_apply, middleEquiv, Matrix.fromBlocks, Matrix.fromRows, |
| Matrix.fromCols, Sum.elim, Matrix.toBlocks₁₁, Matrix.toBlocks₁₂, Matrix.toBlocks₂₁, |
| Matrix.toBlocks₂₂, Matrix.one_apply] |
| have hY : Matrix.reindex (Equiv.sumAssoc α γ β).symm (Equiv.sumAssoc α γ β).symm |
| (Matrix.fromBlocks (1 : Matrix α α ℂ) 0 0 Y) = |
| Matrix.fromBlocks (Matrix.fromBlocks 1 0 0 Y.toBlocks₁₁) |
| (Matrix.fromRows 0 Y.toBlocks₁₂) (Matrix.fromCols 0 Y.toBlocks₂₁) Y.toBlocks₂₂ := by |
| ext i j |
| rcases i with (a|c)|b <;> rcases j with (a'|c')|b' <;> |
| simp [Matrix.reindex_apply, Matrix.fromBlocks, Matrix.fromRows, |
| Matrix.fromCols, Sum.elim, Matrix.toBlocks₁₁, Matrix.toBlocks₁₂, Matrix.toBlocks₂₁, |
| Matrix.toBlocks₂₂, Matrix.one_apply] |
| rw [hX,hY] |
| simp only [join, Matrix.fromBlocks_multiply] |
| ext i j |
| rcases i with (a|c)|b <;> rcases j with (a'|c')|b' <;> |
| simp [Matrix.mul_apply, Fintype.sum_sum_type, Matrix.fromBlocks, |
| Matrix.fromRows, Matrix.fromCols, Sum.elim, Matrix.one_apply] |
| |
| theorem unit (X : Matrix (α ⊕ β) (α ⊕ β) ℂ) (Y : Matrix (γ ⊕ β) (γ ⊕ β) ℂ) |
| (hX : IsUnit X) (hY : IsUnit Y) : IsUnit (join X Y) := by |
| rw [join_eq] |
| exact (unit_reindex _ _ (Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨isUnit_one,hY⟩)).mul |
| (unit_reindex _ _ (Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨hX,isUnit_one⟩)) |
|
|
| theorem price (p : MatrixPrice) (X : Matrix (α ⊕ β) (α ⊕ β) ℂ) |
| (Y : Matrix (γ ⊕ β) (γ ⊕ β) ℂ) (hX : IsUnit X) (hY : IsUnit Y) : |
| p.value (join X Y) ≤ p.value X + p.value Y := by |
| have hX' : IsUnit (Matrix.fromBlocks X 0 0 (1 : Matrix γ γ ℂ)) := |
| Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨hX,isUnit_one⟩ |
| have hY' : IsUnit (Matrix.fromBlocks (1 : Matrix α α ℂ) 0 0 Y) := |
| Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨isUnit_one,hY⟩ |
| rw [join_eq] |
| calc |
| _ ≤ _ := p.mul_le _ _ (unit_reindex _ _ hY') (unit_reindex _ _ hX') |
| _ = _ := by rw [p.reindex _ _ hY',p.reindex _ _ hX', |
| p.directSum _ _ isUnit_one hY,p.identity_pad _ hX,p.one]; ring |
| |
| end CellJoin |
| end ExactFourier |
| |
| end |
| |
| section |
| namespace ExactFourier.Triangular |
| open scoped Kronecker BigOperators |
| open TensorTools |
| |
| variable {α β σ κ : Type} [Fintype α] [Fintype β] [Fintype σ] [Fintype κ] |
| [DecidableEq α] [DecidableEq β] [DecidableEq σ] [DecidableEq κ] |
|
|
| def swapLast : (σ × α) × β ≃ (σ × β) × α where |
| toFun x := ((x.1.1,x.2),x.1.2) |
| invFun x := ((x.1.1,x.2),x.1.2) |
| left_inv := by rintro ⟨⟨s,a⟩,b⟩; rfl |
| right_inv := by rintro ⟨⟨s,b⟩,a⟩; rfl |
| |
| def liftEquiv : ((σ × α) ⊕ κ) × β ≃ ((σ × β) × α) ⊕ (κ × β) := |
| (Equiv.sumProdDistrib _ _ _).trans (Equiv.sumCongr swapLast (Equiv.refl _)) |
|
|
| def oldE (E : Matrix (σ × α) κ ℂ) : Matrix ((σ × β) × α) (κ × β) ℂ := |
| fun i j => E (i.1.1,i.2) j.1 * (1 : Matrix β β ℂ) i.1.2 j.2 |
|
|
| theorem lift_identity |
| {α : Type} {β : Type} {σ : Type} {κ : Type} [Fintype α] [Fintype β] [Fintype σ] [Fintype κ] [DecidableEq α] [DecidableEq β] [DecidableEq σ] [DecidableEq κ] (M : Matrix α α ℂ) (E : Matrix (σ × α) κ ℂ) |
| (Y : Matrix κ κ ℂ) : |
| Matrix.reindex liftEquiv liftEquiv |
| (Matrix.fromBlocks ((1 : Matrix σ σ ℂ) ⊗ₖ M) E 0 Y ⊗ₖ (1 : Matrix β β ℂ)) = |
| Matrix.fromBlocks ((1 : Matrix (σ × β) (σ × β) ℂ) ⊗ₖ M) (oldE E) 0 |
| (Y ⊗ₖ (1 : Matrix β β ℂ)) := by |
| ext i j |
| rcases i with ⟨⟨s,b⟩,a⟩|⟨i,b⟩ <;> rcases j with ⟨⟨s',b'⟩,a'⟩|⟨j,b'⟩ <;> |
| simp [Matrix.reindex_apply, liftEquiv, swapLast, Matrix.kroneckerMap_apply, |
| Matrix.fromBlocks, oldE, Matrix.one_apply, mul_comm, Prod.mk.injEq, and_comm] |
| split_ifs <;> simp_all |
| |
| theorem new_identity |
| {α : Type} {β : Type} {κ : Type} [Fintype α] [Fintype β] [Fintype κ] [DecidableEq α] [DecidableEq β] [DecidableEq κ] (M : Matrix α α ℂ) (C : Matrix α β ℂ) (D : Matrix β β ℂ) : |
| Matrix.reindex (Equiv.prodSumDistrib κ α β) (Equiv.prodSumDistrib κ α β) |
| ((1 : Matrix κ κ ℂ) ⊗ₖ Matrix.fromBlocks M C 0 D) = |
| Matrix.fromBlocks ((1 : Matrix κ κ ℂ) ⊗ₖ M) ((1 : Matrix κ κ ℂ) ⊗ₖ C) 0 |
| ((1 : Matrix κ κ ℂ) ⊗ₖ D) := by |
| ext i j |
| rcases i with ⟨i,a⟩|⟨i,b⟩ <;> rcases j with ⟨j,a'⟩|⟨j,b'⟩ <;> |
| simp [Matrix.reindex_apply, Matrix.kroneckerMap_apply, Matrix.fromBlocks] |
| |
| def nextE (E : Matrix (σ × α) κ ℂ) (Y : Matrix κ κ ℂ) (C : Matrix α β ℂ) : |
| Matrix (((σ × β) ⊕ κ) × α) (κ × β) ℂ := |
| fun i j => match i.1 with |
| | Sum.inl s => E (s.1,i.2) j.1 * (1 : Matrix β β ℂ) s.2 j.2 |
| | Sum.inr k => Y k j.1 * C i.2 j.2 |
|
|
| def mergeEquiv : (((σ × β) × α) ⊕ (κ × α)) ⊕ (κ × β) ≃ |
| (((σ × β) ⊕ κ) × α) ⊕ (κ × β) := |
| Equiv.sumCongr (Equiv.sumProdDistrib (σ × β) κ α).symm (Equiv.refl _) |
|
|
| theorem merge_identity |
| {α : Type} {β : Type} {σ : Type} {κ : Type} [Fintype α] [Fintype β] [Fintype σ] [Fintype κ] [DecidableEq α] [DecidableEq β] [DecidableEq σ] [DecidableEq κ] (M : Matrix α α ℂ) (C : Matrix α β ℂ) (D : Matrix β β ℂ) |
| (E : Matrix (σ × α) κ ℂ) (Y : Matrix κ κ ℂ) : |
| Matrix.reindex mergeEquiv mergeEquiv |
| (Matrix.fromBlocks |
| (Matrix.fromBlocks ((1 : Matrix (σ × β) (σ × β) ℂ) ⊗ₖ M) 0 0 |
| ((1 : Matrix κ κ ℂ) ⊗ₖ M)) |
| (Matrix.fromRows (oldE E) (((1 : Matrix κ κ ℂ) ⊗ₖ C) * |
| (Y ⊗ₖ (1 : Matrix β β ℂ)))) 0 |
| (((1 : Matrix κ κ ℂ) ⊗ₖ D) * (Y ⊗ₖ (1 : Matrix β β ℂ)))) = |
| Matrix.fromBlocks ((1 : Matrix ((σ × β) ⊕ κ) ((σ × β) ⊕ κ) ℂ) ⊗ₖ M) |
| (nextE E Y C) 0 (Y ⊗ₖ D) := by |
| rw [← Matrix.mul_kronecker_mul, ← Matrix.mul_kronecker_mul] |
| simp only [Matrix.one_mul, Matrix.mul_one] |
| ext i j |
| rcases i with ⟨s|k,a⟩|⟨i,b⟩ <;> rcases j with ⟨s'|k',a'⟩|⟨j,b'⟩ <;> |
| simp [Matrix.reindex_apply, mergeEquiv, Matrix.kroneckerMap_apply, |
| Matrix.fromBlocks, Matrix.fromRows, Sum.elim, oldE, nextE, Matrix.one_apply] |
| |
| theorem next_price (p : MatrixPrice) (M : Matrix α α ℂ) (C : Matrix α β ℂ) |
| (D : Matrix β β ℂ) (E : Matrix (σ × α) κ ℂ) (Y : Matrix κ κ ℂ) |
| (hM : IsUnit M) (hD : IsUnit D) (hY : IsUnit Y) : |
| p.value (Matrix.fromBlocks ((1 : Matrix ((σ × β) ⊕ κ) ((σ × β) ⊕ κ) ℂ) ⊗ₖ M) |
| (nextE E Y C) 0 (Y ⊗ₖ D)) ≤ |
| Fintype.card β * p.value (Matrix.fromBlocks ((1 : Matrix σ σ ℂ) ⊗ₖ M) E 0 Y) + |
| Fintype.card κ * p.value (Matrix.fromBlocks M C 0 D) := by |
| have hT : IsUnit (Matrix.fromBlocks ((1 : Matrix σ σ ℂ) ⊗ₖ M) E 0 Y) := |
| Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨unit_tensor _ _ isUnit_one hM,hY⟩ |
| have hK : IsUnit (Matrix.fromBlocks M C 0 D) := |
| Matrix.isUnit_fromBlocks_zero₂₁.mpr ⟨hM,hD⟩ |
| have hh := price_join p ((1 : Matrix (σ × β) (σ × β) ℂ) ⊗ₖ M) |
| ((1 : Matrix κ κ ℂ) ⊗ₖ M) (oldE E) ((1 : Matrix κ κ ℂ) ⊗ₖ C) |
| (Y ⊗ₖ (1 : Matrix β β ℂ)) ((1 : Matrix κ κ ℂ) ⊗ₖ D) |
| (unit_tensor _ _ isUnit_one hM) (unit_tensor _ _ isUnit_one hM) |
| (unit_tensor _ _ hY isUnit_one) (unit_tensor _ _ isUnit_one hD) |
| rw [← lift_identity, ← new_identity] at hh |
| rw [p.reindex _ _ (unit_tensor _ _ hT isUnit_one), |
| p.reindex _ _ (unit_tensor _ _ isUnit_one hK), |
| p.tensor _ _ hT isUnit_one, p.tensor _ _ isUnit_one hK, p.one, p.one] at hh |
| simp only [mul_zero, add_zero, zero_add] at hh |
| rw [← merge_identity, p.reindex] |
| · exact hh |
| · apply Matrix.isUnit_fromBlocks_zero₂₁.mpr |
| constructor |
| · exact Matrix.isUnit_fromBlocks_zero₂₁.mpr |
| ⟨unit_tensor _ _ isUnit_one hM, unit_tensor _ _ isUnit_one hM⟩ |
| · exact (unit_tensor _ _ isUnit_one hD).mul (unit_tensor _ _ hY isUnit_one) |
|
|
| end ExactFourier.Triangular |
|
|
| end |
|
|
| section |
| /-! Whole-row-block compression used in the proof of triangular monotonicity |
| (05-corners.tex:145–209). Only the block-copy index is changed; individual rows |
| of a spatial block are never independently mixed. -/ |
| namespace ExactFourier.RowCompression |
| open scoped BigOperators |
| |
| section Splitting |
| variable {K E F : Type*} [Field K] [AddCommGroup E] [Module K E] |
| [AddCommGroup F] [Module K F] |
|
|
| /-- A chosen linear right inverse splits a surjection with its kernel. -/ |
| def splitEquiv (f : E →ₗ[K] F) (s : F →ₗ[K] E) |
| (hs : f.comp s = LinearMap.id) : E ≃ₗ[K] F × LinearMap.ker f where |
| toFun x := (f x, ⟨x-s (f x), by |
| change f (x-s (f x)) = 0 |
| have h := LinearMap.congr_fun hs (f x) |
| simpa using sub_eq_zero.mpr h.symm⟩) |
| invFun x := s x.1 + x.2 |
| left_inv x := by simp |
| right_inv x := by |
| apply Prod.ext |
| · have h : f (s x.1) = x.1 := LinearMap.congr_fun hs x.1 |
| have hx : f (x.2 : E) = 0 := x.2.property |
| simp only [map_add, h, hx, add_zero] |
| · apply Subtype.ext |
| have h : f (s x.1) = x.1 := LinearMap.congr_fun hs x.1 |
| have hx : f (x.2 : E) = 0 := x.2.property |
| simp only [map_add, h, hx, add_zero] |
| abel |
| map_add' x y := by |
| apply Prod.ext |
| · exact map_add f x y |
| · apply Subtype.ext |
| simp only [Prod.snd_add, Submodule.coe_add, map_add] |
| abel |
| map_smul' c x := by |
| apply Prod.ext |
| · exact map_smul f c x |
| · apply Subtype.ext |
| simp [smul_sub] |
|
|
| @[simp] theorem splitEquiv_fst (f : E →ₗ[K] F) (s : F →ₗ[K] E) |
| (hs : f.comp s = LinearMap.id) (x : E) : (splitEquiv f s hs x).1 = f x := rfl |
|
|
| /-- Two surjections from the same finite-dimensional domain differ by an |
| invertible change of domain. This is the block-copy coordinate change V. -/ |
| theorem surjective_equiv [FiniteDimensional K E] (f g : E →ₗ[K] F) |
| (hf : Function.Surjective f) (hg : Function.Surjective g) : |
| ∃ e : E ≃ₗ[K] E, ∀ x, f (e x) = g x := by |
| obtain ⟨s, hs⟩ := f.exists_rightInverse_of_surjective (LinearMap.range_eq_top.mpr hf) |
| obtain ⟨t, ht⟩ := g.exists_rightInverse_of_surjective (LinearMap.range_eq_top.mpr hg) |
| have hd : Module.finrank K (LinearMap.ker g) = Module.finrank K (LinearMap.ker f) := by |
| have h1 := f.finrank_range_add_finrank_ker |
| have h2 := g.finrank_range_add_finrank_ker |
| rw [LinearMap.range_eq_top.mpr hf] at h1 |
| rw [LinearMap.range_eq_top.mpr hg] at h2 |
| omega |
| let a : LinearMap.ker g ≃ₗ[K] LinearMap.ker f := LinearEquiv.ofFinrankEq _ _ hd |
| let e := (splitEquiv g t ht).trans |
| ((LinearEquiv.prodCongr (LinearEquiv.refl K F) a).trans (splitEquiv f s hs).symm) |
| refine ⟨e, ?_⟩ |
| intro x |
| have h := congrArg Prod.fst ((splitEquiv f s hs).apply_symm_apply |
| (g x, a (splitEquiv g t ht x).2)) |
| exact h |
|
|
| /-- Equality of row spaces, not an assumption of full row rank, suffices. -/ |
| theorem range_equiv [FiniteDimensional K E] (f g : E →ₗ[K] F) |
| (hfg : LinearMap.range f = LinearMap.range g) : |
| ∃ e : E ≃ₗ[K] E, ∀ x, f (e x) = g x := by |
| let g' : E →ₗ[K] LinearMap.range f := g.codRestrict (LinearMap.range f) |
| (by intro x; rw [hfg]; exact LinearMap.mem_range_self g x) |
| have hg' : Function.Surjective g' := by |
| rintro ⟨y, hy⟩ |
| rw [hfg] at hy |
| obtain ⟨x, rfl⟩ := hy |
| exact ⟨x, rfl⟩ |
| obtain ⟨e, he⟩ := surjective_equiv f.rangeRestrict g' |
| (LinearMap.range_eq_top.mp f.range_rangeRestrict) hg' |
| exact ⟨e, fun x => congrArg Subtype.val (he x)⟩ |
|
|
| end Splitting |
| section Matrices |
| variable {K α β : Type*} [Field K] [Fintype α] [DecidableEq α] |
|
|
| /-- The row-space equivalence as an actual invertible left multiplier. -/ |
| theorem matrix_row_equiv (R S : Matrix α β K) |
| (hRS : Submodule.span K (Set.range R) = Submodule.span K (Set.range S)) : |
| ∃ V : Matrix α α K, IsUnit V ∧ V * R = S := by |
| obtain ⟨e, he⟩ := range_equiv R.vecMulLinear S.vecMulLinear |
| (by simpa only [range_vecMulLinear, Matrix.row] using hRS) |
| let V := e.toLinearMap.toMatrixRight' |
| let W := e.symm.toLinearMap.toMatrixRight' |
| have hVW : V * W = 1 := by |
| rw [← LinearMap.toMatrixRight'_comp] |
| have h : e.symm.toLinearMap.comp e.toLinearMap = LinearMap.id := by ext x; simp |
| rw [h, LinearMap.toMatrixRight'_id] |
| have hWV : W * V = 1 := by |
| rw [← LinearMap.toMatrixRight'_comp] |
| have h : e.toLinearMap.comp e.symm.toLinearMap = LinearMap.id := by ext x; simp |
| rw [h, LinearMap.toMatrixRight'_id] |
| refine ⟨V, ⟨⟨V, W, hVW, hWV⟩, rfl⟩, ?_⟩ |
| apply Matrix.toLinearMapRight'.injective |
| rw [Matrix.toLinearMapRight'_mul] |
| change R.vecMulLinear.comp (LinearMap.toMatrixRight'.symm |
| (LinearMap.toMatrixRight' e.toLinearMap)) = S.vecMulLinear |
| rw [LinearEquiv.symm_apply_apply] |
| exact LinearMap.ext he |
| |
| /-- Select a sparse spanning-family basis and perform the invertible compression |
| on the *whole* row-block index. At most dim(β → K) rows remain. -/ |
| theorem sparse_row_compression {γ : Type*} [Fintype β] (R : Matrix α β K) |
| (Q : γ → β → K) |
| (hspan : Submodule.span K (Set.range R) = Submodule.span K (Set.range Q)) : |
| ∃ V : Matrix α α K, IsUnit V ∧ ∃ I : Finset α, |
| I.card ≤ Fintype.card β ∧ |
| (∀ i, i ∉ I → (V*R) i = 0) ∧ |
| (∀ i ∈ I, ∃ g, (V*R) i = Q g) := by |
| classical |
| obtain ⟨t, htQ, htcard, htspan, hti⟩ := |
| Submodule.exists_finset_span_eq_linearIndepOn K (Set.range Q) |
| have hta : Fintype.card t ≤ Fintype.card α := by |
| rw [Fintype.card_coe, htcard, ← hspan] |
| exact finrank_range_le_card R |
| have htb : t.card ≤ Fintype.card β := by |
| rw [htcard] |
| simpa using (Submodule.finrank_le (Submodule.span K (Set.range Q))) |
| let e : t ↪ α := Classical.choice (Function.Embedding.nonempty_of_card_le hta) |
| let S : Matrix α β K := fun i => if h : ∃ b : t, e b = i then (h.choose : β → K) else 0 |
| have hSe (b : t) : S (e b) = b := by |
| dsimp only [S] |
| have hb : ∃ c : t, e c = e b := ⟨b,rfl⟩ |
| rw [dite_eq_left hb] |
| exact congrArg Subtype.val (e.injective hb.choose_spec) |
| have hspanS : Submodule.span K (Set.range S) = Submodule.span K (t : Set (β → K)) := by |
| apply le_antisymm |
| · apply Submodule.span_le.mpr |
| rintro _ ⟨i,rfl⟩ |
| dsimp only [S] |
| split_ifs with hi |
| · exact Submodule.subset_span hi.choose.property |
| · exact Submodule.zero_mem _ |
| · apply Submodule.span_le.mpr |
| intro b hb |
| exact Submodule.subset_span ⟨e ⟨b,hb⟩, hSe ⟨b,hb⟩⟩ |
| have hRS : Submodule.span K (Set.range R) = Submodule.span K (Set.range S) := by |
| rw [hspanS, htspan, hspan] |
| obtain ⟨V,hV,hVS⟩ := matrix_row_equiv R S hRS |
| let I := Finset.univ.map e |
| refine ⟨V,hV,I, ?_, ?_, ?_⟩ |
| · simpa [I] using htb |
| · intro i hi |
| rw [hVS] |
|
|
| dsimp [S] |
| apply dite_eq_right |
| simpa [I] using hi |
| · intro i hi |
| obtain ⟨b, _, rfl⟩ := Finset.mem_map.mp hi |
| have hbQ := htQ b.property |
| obtain ⟨g,hg⟩ := hbQ |
| refine ⟨g, ?_⟩ |
| rw [hVS, hSe, hg] |
|
|
| end Matrices |
| end ExactFourier.RowCompression |
|
|
| end |
|
|
| end OAI |
|
|
