openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixFields /Tensors /ComplexSeparatedTensorDecomposition.lean
| import Mathlib | |
| import OAI.LinearAlgebra.MatrixFields.Extraction.ComplexFiniteSeparation | |
| namespace OAI | |
| namespace MatrixAllFields | |
| open scoped BigOperators Topology Polynomial | |
| open scoped BigOperators | |
| namespace MatrixMultiplication.Foundation | |
| namespace Tensor | |
| variable {K S : Type*} [CommSemiring K] [DecidableEq S] | |
| variable {X Y Z : S → Type*} | |
| def dependentDirectSum (T : ∀ s, Tensor K (X s) (Y s) (Z s)) : | |
| Tensor K (Σ s, X s) (Σ s, Y s) (Σ s, Z s) := | |
| fun x y z => | |
| if hxy : y.1 = x.1 then | |
| if hxz : z.1 = x.1 then T x.1 x.2 (hxy ▸ y.2) (hxz ▸ z.2) | |
| else 0 | |
| else 0 | |
| @[simp] theorem dependentDirectSum_matching | |
| (T : ∀ s, Tensor K (X s) (Y s) (Z s)) | |
| (s : S) (x : X s) (y : Y s) (z : Z s) : | |
| dependentDirectSum T ⟨s, x⟩ ⟨s, y⟩ ⟨s, z⟩ = T s x y z := by | |
| simp [dependentDirectSum] | |
| theorem dependentDirectSum_zero_of_left_ne | |
| (T : ∀ s, Tensor K (X s) (Y s) (Z s)) | |
| (x : Σ s, X s) (y : Σ s, Y s) (z : Σ s, Z s) | |
| (h : x.1 ≠ y.1) : dependentDirectSum T x y z = 0 := by | |
| simp [dependentDirectSum, Ne.symm h] | |
| def directSumCoordinateEquiv {A : Type*} (e : ∀ s, X s ≃ A) : | |
| (Σ s, X s) ≃ S × A where | |
| toFun x := (x.1, e x.1 x.2) | |
| invFun x := ⟨x.1, (e x.1).symm x.2⟩ | |
| left_inv := by | |
| rintro ⟨s, x⟩ | |
| simp | |
| right_inv := by | |
| rintro ⟨s, x⟩ | |
| simp | |
| theorem dependentDirectSum_reindex {A B C : Type*} | |
| (T : ∀ s, Tensor K (X s) (Y s) (Z s)) | |
| (ex : ∀ s, X s ≃ A) (ey : ∀ s, Y s ≃ B) (ez : ∀ s, Z s ≃ C) : | |
| pullback (directSumCoordinateEquiv ex).symm | |
| (directSumCoordinateEquiv ey).symm (directSumCoordinateEquiv ez).symm | |
| (dependentDirectSum T) = | |
| directSum (fun s => pullback (ex s).symm (ey s).symm (ez s).symm (T s)) := by | |
| funext x y z | |
| rcases x with ⟨s, x⟩ | |
| rcases y with ⟨t, y⟩ | |
| rcases z with ⟨v, z⟩ | |
| by_cases ht : t = s | |
| · subst t | |
| by_cases hv : v = s | |
| · subst v | |
| simp [pullback, directSumCoordinateEquiv, dependentDirectSum, directSum] | |
| · simp [pullback, directSumCoordinateEquiv, dependentDirectSum, directSum, | |
| hv, Ne.symm hv] | |
| · simp [pullback, directSumCoordinateEquiv, dependentDirectSum, directSum, | |
| ht, Ne.symm ht] | |
| end Tensor | |
| variable {X Y Z S U : Type*} [DecidableEq S] [DecidableEq U] | |
| def labelFiberTensor (lx : X → S) (ly : Y → S) (T : Tensor ℂ X Y Z) (s : S) : | |
| Tensor ℂ {x // lx x = s} {y // ly y = s} Z := | |
| fun x y z => T x.1 y.1 z | |
| def fiberCoordinateEquiv (lx : X → S) : | |
| (Σ s, {x // lx x = s} × U) ≃ X × U where | |
| toFun x := (x.2.1.1, x.2.2) | |
| invFun x := ⟨lx x.1, (⟨x.1, rfl⟩, x.2)⟩ | |
| left_inv := by | |
| rintro ⟨s, ⟨⟨x, hx⟩, u⟩⟩ | |
| cases hx | |
| rfl | |
| right_inv := by | |
| rintro ⟨x, u⟩ | |
| rfl | |
| def tagCoordinateEquiv : (Σ _ : S, Z × Unit) ≃ Z × S where | |
| toFun z := (z.2.1, z.1) | |
| invFun z := ⟨z.2, (z.1, ())⟩ | |
| left_inv := by | |
| rintro ⟨s, z, u⟩ | |
| cases u | |
| rfl | |
| right_inv := by | |
| rintro ⟨z, s⟩ | |
| rfl | |
| theorem separatedTensor_eq_fiber_directSum | |
| (T : Tensor ℂ X Y Z) (lx : X → S) (ly : Y → S) | |
| (hlabels : ∀ x y z, T x y z ≠ 0 → lx x = ly y) : | |
| Tensor.pullback (fiberCoordinateEquiv (U := U) lx) | |
| (fiberCoordinateEquiv (U := U) ly) (tagCoordinateEquiv (Z := Z) (S := S)) | |
| (separatedTensor lx T) = | |
| Tensor.dependentDirectSum (fun s => | |
| Tensor.product (labelFiberTensor lx ly T s) (Tensor.dotPairing U)) := by | |
| classical | |
| funext x y z | |
| rcases x with ⟨s, x, u⟩ | |
| rcases y with ⟨t, y, v⟩ | |
| rcases z with ⟨w, z, q⟩ | |
| by_cases ht : t = s | |
| · subst t | |
| by_cases hw : w = s | |
| · subst w | |
| rw [Tensor.dependentDirectSum_matching] | |
| simp [Tensor.pullback, fiberCoordinateEquiv, tagCoordinateEquiv, | |
| separatedTensor, Tensor.product, labelFiberTensor, Tensor.dotPairing, | |
| x.property, mul_ite] | |
| · simp [Tensor.pullback, fiberCoordinateEquiv, tagCoordinateEquiv, | |
| separatedTensor, Tensor.dependentDirectSum, x.property, hw, Ne.symm hw] | |
| · have hzero : T x.1 y.1 z = 0 := by | |
| by_contra hzero | |
| have hxy := hlabels x.1 y.1 z hzero | |
| exact ht (y.property.symm.trans (hxy.symm.trans x.property)) | |
| simp [Tensor.pullback, fiberCoordinateEquiv, tagCoordinateEquiv, | |
| separatedTensor, Tensor.dependentDirectSum, ht, hzero] | |
| theorem fiber_directSum_eq_separatedTensor | |
| (T : Tensor ℂ X Y Z) (lx : X → S) (ly : Y → S) | |
| (hlabels : ∀ x y z, T x y z ≠ 0 → lx x = ly y) : | |
| Tensor.pullback (fiberCoordinateEquiv (U := U) lx).symm | |
| (fiberCoordinateEquiv (U := U) ly).symm | |
| (tagCoordinateEquiv (Z := Z) (S := S)).symm | |
| (Tensor.dependentDirectSum (fun s => | |
| Tensor.product (labelFiberTensor lx ly T s) (Tensor.dotPairing U))) = | |
| separatedTensor lx T := by | |
| rw [← separatedTensor_eq_fiber_directSum T lx ly hlabels] | |
| funext x y z | |
| simp [Tensor.pullback] | |
| theorem separatedTensor_fiber_directSum_rankAtMost | |
| (T : Tensor ℂ X Y Z) (lx : X → S) (ly : Y → S) {r : ℕ} | |
| (hlabels : ∀ x y z, T x y z ≠ 0 → lx x = ly y) | |
| (h : Tensor.RankAtMost (separatedTensor (U := U) lx T) r) : | |
| Tensor.RankAtMost (Tensor.dependentDirectSum (fun s => | |
| Tensor.product (labelFiberTensor lx ly T s) (Tensor.dotPairing U))) r := by | |
| rw [← separatedTensor_eq_fiber_directSum T lx ly hlabels] | |
| exact h.pullback _ _ _ | |
| theorem separatedTensor_fiber_directSum_rankAtMost_iff | |
| (T : Tensor ℂ X Y Z) (lx : X → S) (ly : Y → S) {r : ℕ} | |
| (hlabels : ∀ x y z, T x y z ≠ 0 → lx x = ly y) : | |
| Tensor.RankAtMost (separatedTensor (U := U) lx T) r ↔ | |
| Tensor.RankAtMost (Tensor.dependentDirectSum (fun s => | |
| Tensor.product (labelFiberTensor lx ly T s) (Tensor.dotPairing U))) r := by | |
| constructor | |
| · exact separatedTensor_fiber_directSum_rankAtMost T lx ly hlabels | |
| · intro h | |
| rw [← fiber_directSum_eq_separatedTensor T lx ly hlabels] | |
| exact h.pullback _ _ _ | |
| theorem separatedTensor_fiber_directSum_borderRankAtMost | |
| [Fintype X] [Fintype Y] [Fintype Z] [Fintype S] [Fintype U] | |
| (T : Tensor ℂ X Y Z) (lx : X → S) (ly : Y → S) {r : ℕ} | |
| (hlabels : ∀ x y z, T x y z ≠ 0 → lx x = ly y) | |
| (h : Tensor.BorderRankAtMost (separatedTensor (U := U) lx T) r) : | |
| Tensor.BorderRankAtMost (Tensor.dependentDirectSum (fun s => | |
| Tensor.product (labelFiberTensor lx ly T s) (Tensor.dotPairing U))) r := by | |
| classical | |
| rw [← separatedTensor_eq_fiber_directSum T lx ly hlabels] | |
| rw [Tensor.pullback_eq_restrict] | |
| exact h.restrict _ _ _ | |
| theorem separatedTensor_uniform_directSum_rankAtMost {A B : Type*} | |
| (T : Tensor ℂ X Y Z) (lx : X → S) (ly : Y → S) | |
| (ex : ∀ s, {x // lx x = s} ≃ A) (ey : ∀ s, {y // ly y = s} ≃ B) | |
| {r : ℕ} (hlabels : ∀ x y z, T x y z ≠ 0 → lx x = ly y) | |
| (h : Tensor.RankAtMost (separatedTensor (U := U) lx T) r) : | |
| Tensor.RankAtMost (Tensor.directSum (fun s => Tensor.pullback | |
| (Equiv.prodCongr (ex s) (Equiv.refl U)).symm | |
| (Equiv.prodCongr (ey s) (Equiv.refl U)).symm | |
| (Equiv.refl (Z × Unit)).symm | |
| (Tensor.product (labelFiberTensor lx ly T s) (Tensor.dotPairing U)))) r := by | |
| have hf := separatedTensor_fiber_directSum_rankAtMost T lx ly hlabels h | |
| have hp := hf.pullback | |
| (Tensor.directSumCoordinateEquiv | |
| (fun s => Equiv.prodCongr (ex s) (Equiv.refl U))).symm | |
| (Tensor.directSumCoordinateEquiv | |
| (fun s => Equiv.prodCongr (ey s) (Equiv.refl U))).symm | |
| (Tensor.directSumCoordinateEquiv (fun _ : S => Equiv.refl (Z × Unit))).symm | |
| rw [Tensor.dependentDirectSum_reindex] at hp | |
| exact hp | |
| theorem separatedTensor_localModels_identity {A B C : Type*} | |
| (T : Tensor ℂ X Y Z) (lx : X → S) (ly : Y → S) | |
| (fx : S → A → X) (fy : S → B → Y) (fz : S → C → Z) | |
| (hfx : ∀ s a, lx (fx s a) = s) (hfy : ∀ s b, ly (fy s b) = s) | |
| (hlabels : ∀ x y z, T x y z ≠ 0 → lx x = ly y) : | |
| Tensor.pullback | |
| (fun x : S × (A × U) => (fx x.1 x.2.1, x.2.2)) | |
| (fun y : S × (B × U) => (fy y.1 y.2.1, y.2.2)) | |
| (fun z : S × (C × Unit) => (fz z.1 z.2.1, z.1)) | |
| (separatedTensor lx T) = | |
| Tensor.directSum (fun s => Tensor.product | |
| (Tensor.pullback (fx s) (fy s) (fz s) T) (Tensor.dotPairing U)) := by | |
| funext x y z | |
| rcases x with ⟨s, a, u⟩ | |
| rcases y with ⟨t, b, v⟩ | |
| rcases z with ⟨w, c, q⟩ | |
| by_cases ht : t = s | |
| · subst t | |
| by_cases hw : w = s | |
| · subst w | |
| simp [Tensor.pullback, separatedTensor, Tensor.directSum, | |
| Tensor.product, Tensor.dotPairing, hfx, mul_ite] | |
| · simp [Tensor.pullback, separatedTensor, Tensor.directSum, | |
| hfx, Ne.symm hw] | |
| · have hzero : T (fx s a) (fy t b) (fz w c) = 0 := by | |
| by_contra hzero | |
| have hxy := hlabels (fx s a) (fy t b) (fz w c) hzero | |
| exact ht ((hfy t b).symm.trans (hxy.symm.trans (hfx s a))) | |
| simp [Tensor.pullback, separatedTensor, Tensor.directSum, | |
| Ne.symm ht, hzero] | |
| theorem separatedTensor_localModels_rankAtMost {A B C : Type*} | |
| (T : Tensor ℂ X Y Z) (lx : X → S) (ly : Y → S) | |
| (fx : S → A → X) (fy : S → B → Y) (fz : S → C → Z) | |
| (hfx : ∀ s a, lx (fx s a) = s) (hfy : ∀ s b, ly (fy s b) = s) | |
| (hlabels : ∀ x y z, T x y z ≠ 0 → lx x = ly y) | |
| {r : ℕ} (h : Tensor.RankAtMost (separatedTensor (U := U) lx T) r) : | |
| Tensor.RankAtMost (Tensor.directSum (fun s => Tensor.product | |
| (Tensor.pullback (fx s) (fy s) (fz s) T) (Tensor.dotPairing U))) r := by | |
| rw [← separatedTensor_localModels_identity T lx ly fx fy fz hfx hfy hlabels] | |
| exact h.pullback _ _ _ | |
| theorem separatedTensor_localModels_borderRankAtMost {A B C : Type*} | |
| [Fintype X] [Fintype Y] [Fintype Z] [Fintype S] [Fintype U] | |
| [Fintype A] [Fintype B] [Fintype C] | |
| (T : Tensor ℂ X Y Z) (lx : X → S) (ly : Y → S) | |
| (fx : S → A → X) (fy : S → B → Y) (fz : S → C → Z) | |
| (hfx : ∀ s a, lx (fx s a) = s) (hfy : ∀ s b, ly (fy s b) = s) | |
| (hlabels : ∀ x y z, T x y z ≠ 0 → lx x = ly y) | |
| {r : ℕ} (h : Tensor.BorderRankAtMost (separatedTensor (U := U) lx T) r) : | |
| Tensor.BorderRankAtMost (Tensor.directSum (fun s => Tensor.product | |
| (Tensor.pullback (fx s) (fy s) (fz s) T) (Tensor.dotPairing U))) r := by | |
| classical | |
| rw [← separatedTensor_localModels_identity T lx ly fx fy fz hfx hfy hlabels] | |
| rw [Tensor.pullback_eq_restrict] | |
| exact h.restrict _ _ _ | |
| theorem separatedTensor_scalar_identity | |
| (T : Tensor ℂ X Y Z) (lx : X → S) (ly : Y → S) | |
| (sx : S → X) (sy : S → Y) (sz : S → Z) | |
| (hsx : ∀ s, lx (sx s) = s) (hsy : ∀ s, ly (sy s) = s) | |
| (hlabels : ∀ x y z, T x y z ≠ 0 → lx x = ly y) | |
| (hscalar : ∀ s, T (sx s) (sy s) (sz s) = 1) : | |
| Tensor.pullback | |
| (fun x : S × U => (sx x.1, x.2)) | |
| (fun y : S × U => (sy y.1, y.2)) | |
| (fun z : S × Unit => (sz z.1, z.1)) (separatedTensor lx T) = | |
| Tensor.directSum (fun _ : S => Tensor.dotPairing U) := by | |
| have hmodels := separatedTensor_localModels_identity (U := U) T lx ly | |
| (fun s (_ : Unit) => sx s) (fun s (_ : Unit) => sy s) (fun s (_ : Unit) => sz s) | |
| (fun s _ => hsx s) (fun s _ => hsy s) hlabels | |
| have h := congrArg (Tensor.pullback | |
| (fun x : S × U => (x.1, ((), x.2))) | |
| (fun y : S × U => (y.1, ((), y.2))) | |
| (fun z : S × Unit => (z.1, ((), z.2)))) hmodels | |
| funext x y z | |
| have hpoint := congrFun (congrFun (congrFun h x) y) z | |
| simpa only [Tensor.pullback, Tensor.directSum, Tensor.product, hscalar, one_mul] | |
| using hpoint | |
| theorem separatedTensor_scalar_rankAtMost | |
| (T : Tensor ℂ X Y Z) (lx : X → S) (ly : Y → S) | |
| (sx : S → X) (sy : S → Y) (sz : S → Z) | |
| (hsx : ∀ s, lx (sx s) = s) (hsy : ∀ s, ly (sy s) = s) | |
| (hlabels : ∀ x y z, T x y z ≠ 0 → lx x = ly y) | |
| (hscalar : ∀ s, T (sx s) (sy s) (sz s) = 1) | |
| {r : ℕ} (h : Tensor.RankAtMost (separatedTensor (U := U) lx T) r) : | |
| Tensor.RankAtMost (Tensor.directSum (fun _ : S => Tensor.dotPairing (K := ℂ) U)) r := by | |
| rw [← separatedTensor_scalar_identity T lx ly sx sy sz hsx hsy hlabels hscalar] | |
| exact h.pullback _ _ _ | |
| theorem separatedTensor_scalar_borderRankAtMost | |
| [Fintype X] [Fintype Y] [Fintype Z] [Fintype S] [Fintype U] | |
| (T : Tensor ℂ X Y Z) (lx : X → S) (ly : Y → S) | |
| (sx : S → X) (sy : S → Y) (sz : S → Z) | |
| (hsx : ∀ s, lx (sx s) = s) (hsy : ∀ s, ly (sy s) = s) | |
| (hlabels : ∀ x y z, T x y z ≠ 0 → lx x = ly y) | |
| (hscalar : ∀ s, T (sx s) (sy s) (sz s) = 1) | |
| {r : ℕ} (h : Tensor.BorderRankAtMost (separatedTensor (U := U) lx T) r) : | |
| Tensor.BorderRankAtMost (Tensor.directSum (fun _ : S => Tensor.dotPairing U)) r := by | |
| classical | |
| rw [← separatedTensor_scalar_identity T lx ly sx sy sz hsx hsy hlabels hscalar] | |
| rw [Tensor.pullback_eq_restrict] | |
| exact h.restrict _ _ _ | |
| end MatrixMultiplication.Foundation | |
| end MatrixAllFields | |
| end OAI | |