openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Separation /ComplexPrefixSeparationOrientations.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Polynomial.ComplexPrefixSeparationPolynomialStage | |
| namespace OAI | |
| /-! Finite type counts, hierarchy separation and tensor execution bounds. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.Foundation.PrefixSeparationOrientations | |
| open Tensor LabelHierarchySeparation PolynomialLocalConstruction | |
| open PrefixSeparationPolynomialStage | |
| variable {Prefix X Y Z : Type*} | |
| def auxiliaryXZ (k : ℕ) : | |
| Tensor ℂ (PoolAuxiliaryGroup k) (PoolAuxiliaryGroup k) (PoolAuxiliaryGroup k) := | |
| fun a b c => poolAuxiliaryTensor k a c b | |
| def auxiliaryYZ (k : ℕ) : | |
| Tensor ℂ (PoolAuxiliaryGroup k) (PoolAuxiliaryGroup k) (PoolAuxiliaryGroup k) := | |
| fun a b c => poolAuxiliaryTensor k b c a | |
| theorem auxiliaryXZ_rankAtMost (k : ℕ) : | |
| RankAtMost (auxiliaryXZ k) (poolAuxiliaryCost k) := by | |
| obtain ⟨a, b, c, h⟩ := poolAuxiliaryTensor_rankAtMost k | |
| refine ⟨a, c, b, ?_⟩ | |
| funext x y z | |
| change poolAuxiliaryTensor k x z y = _ | |
| rw [h] | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| simp only [rankOne] | |
| ring | |
| theorem auxiliaryYZ_rankAtMost (k : ℕ) : | |
| RankAtMost (auxiliaryYZ k) (poolAuxiliaryCost k) := by | |
| obtain ⟨a, b, c, h⟩ := poolAuxiliaryTensor_rankAtMost k | |
| refine ⟨c, a, b, ?_⟩ | |
| funext x y z | |
| change poolAuxiliaryTensor k y z x = _ | |
| rw [h] | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| simp only [rankOne] | |
| ring | |
| def stageLeadingXZ (k : ℕ) | |
| (codeX : Prefix → X → Fin k) (codeZ : Prefix → Z → Fin k) | |
| (keepX : Prefix → X → Prop) (keepY : Prefix → Y → Prop) | |
| (keepZ : Prefix → Z → Prop) (prior : Prefix) : | |
| Tensor ℂ (X × InformedOutput k) (Y × MissingOutput k) (Z × InformedOutput k) := | |
| fun x y z => stageLeading k codeX codeZ keepX keepZ keepY prior x z y | |
| def stageLeadingYZ (k : ℕ) | |
| (codeY : Prefix → Y → Fin k) (codeZ : Prefix → Z → Fin k) | |
| (keepX : Prefix → X → Prop) (keepY : Prefix → Y → Prop) | |
| (keepZ : Prefix → Z → Prop) (prior : Prefix) : | |
| Tensor ℂ (X × MissingOutput k) (Y × InformedOutput k) (Z × InformedOutput k) := | |
| fun x y z => stageLeading k codeY codeZ keepY keepZ keepX prior y z x | |
| theorem stageLeadingXZ_synchronized (k : ℕ) | |
| (codeX : Prefix → X → Fin k) (codeZ : Prefix → Z → Fin k) | |
| (keepX : Prefix → X → Prop) (keepY : Prefix → Y → Prop) | |
| (keepZ : Prefix → Z → Prop) (prior : Prefix) | |
| (x : X × InformedOutput k) (y : Y × MissingOutput k) (z : Z × InformedOutput k) | |
| (codes : codeX prior x.1 = codeZ prior z.1) | |
| (nonzero : stageLeadingXZ k codeX codeZ keepX keepY keepZ prior x y z ≠ 0) : | |
| x.2.1 = y.2.1 ∧ x.2.1 = z.2.1 ∧ x.2.2 = z.2.2 := by | |
| obtain ⟨hxz, hxy, hij⟩ := stageLeading_synchronized k codeX codeZ | |
| keepX keepZ keepY prior x z y codes nonzero | |
| exact ⟨hxy, hxz, hij⟩ | |
| theorem stageLeadingYZ_synchronized (k : ℕ) | |
| (codeY : Prefix → Y → Fin k) (codeZ : Prefix → Z → Fin k) | |
| (keepX : Prefix → X → Prop) (keepY : Prefix → Y → Prop) | |
| (keepZ : Prefix → Z → Prop) (prior : Prefix) | |
| (x : X × MissingOutput k) (y : Y × InformedOutput k) (z : Z × InformedOutput k) | |
| (codes : codeY prior y.1 = codeZ prior z.1) | |
| (nonzero : stageLeadingYZ k codeY codeZ keepX keepY keepZ prior x y z ≠ 0) : | |
| x.2.1 = y.2.1 ∧ x.2.1 = z.2.1 ∧ y.2.2 = z.2.2 := by | |
| obtain ⟨hyz, hyx, hij⟩ := stageLeading_synchronized k codeY codeZ | |
| keepY keepZ keepX prior y z x codes nonzero | |
| exact ⟨hyx.symm, hyx.symm.trans hyz, hij⟩ | |
| theorem stageLeadingXZ_retains_pairing (k : ℕ) | |
| (codeX : Prefix → X → Fin k) (codeZ : Prefix → Z → Fin k) | |
| (keepX : Prefix → X → Prop) (keepY : Prefix → Y → Prop) | |
| (keepZ : Prefix → Z → Prop) (prior : Prefix) (x : X) (y : Y) (z : Z) | |
| (hx : keepX prior x) (hy : keepY prior y) (hz : keepZ prior z) | |
| (codes : codeX prior x = codeZ prior z) (i : Fin k) : | |
| stageLeadingXZ k codeX codeZ keepX keepY keepZ prior | |
| (x, (codeX prior x, i)) (y, (codeX prior x, PUnit.unit)) | |
| (z, (codeX prior x, i)) = 1 := | |
| stageLeading_retains_pairing k codeX codeZ keepX keepZ keepY prior x z y hx hz hy codes i | |
| theorem stageLeadingYZ_retains_pairing (k : ℕ) | |
| (codeY : Prefix → Y → Fin k) (codeZ : Prefix → Z → Fin k) | |
| (keepX : Prefix → X → Prop) (keepY : Prefix → Y → Prop) | |
| (keepZ : Prefix → Z → Prop) (prior : Prefix) (x : X) (y : Y) (z : Z) | |
| (hx : keepX prior x) (hy : keepY prior y) (hz : keepZ prior z) | |
| (codes : codeY prior y = codeZ prior z) (i : Fin k) : | |
| stageLeadingYZ k codeY codeZ keepX keepY keepZ prior | |
| (x, (codeY prior y, PUnit.unit)) (y, (codeY prior y, i)) | |
| (z, (codeY prior y, i)) = 1 := | |
| stageLeading_retains_pairing k codeY codeZ keepY keepZ keepX prior y z x hy hz hx codes i | |
| theorem exists_prefix_stage_XZ (k : ℕ) | |
| (codeX : Prefix → X → Fin k) (codeZ : Prefix → Z → Fin k) | |
| (keepX : Prefix → X → Prop) (keepY : Prefix → Y → Prop) | |
| (keepZ : Prefix → Z → Prop) | |
| (eligible : Prefix → X → Y → Z → Prop) | |
| (agree : ∀ p x y z, eligible p x y z → codeX p x = codeZ p z) : | |
| ∃ (MX : Prefix → X → InformedOutput k → PoolAuxiliaryGroup k → Polynomial ℂ) | |
| (MY : Prefix → Y → MissingOutput k → PoolAuxiliaryGroup k → Polynomial ℂ) | |
| (MZ : Prefix → Z → InformedOutput k → PoolAuxiliaryGroup k → Polynomial ℂ), | |
| (∀ p x u i, (MX p x u i).degree ≤ (0 : ℕ)) ∧ | |
| (∀ p y v j, (MY p y v j).degree ≤ (0 : ℕ)) ∧ | |
| (∀ p z w l, (MZ p z w l).degree ≤ (0 : ℕ)) ∧ | |
| ∀ p x y z, eligible p x.1 y.1 z.1 → | |
| kernel (auxiliaryXZ k) (MX p) (MY p) (MZ p) x y z = | |
| Polynomial.C (stageLeadingXZ k codeX codeZ keepX keepY keepZ p x y z) := by | |
| classical | |
| obtain ⟨left, right, tag, coefficients⟩ := exists_auxiliary_coordinates k | |
| let fx : Prefix → X × InformedOutput k → PoolAuxiliaryGroup k := | |
| fun p x => left (codeX p x.1) x.2.2 | |
| let fy : Prefix → Y × MissingOutput k → PoolAuxiliaryGroup k := fun _ y => tag y.2.1 | |
| let fz : Prefix → Z × InformedOutput k → PoolAuxiliaryGroup k := | |
| fun p z => right (codeZ p z.1) z.2.2 | |
| let MX := fun p => weightedCoordinatePolynomialMatrix (fx p) | |
| (informedWeight (keepX p) (codeX p)) | |
| let MY := fun p => weightedCoordinatePolynomialMatrix (fy p) (missingWeight (keepY p)) | |
| let MZ := fun p => weightedCoordinatePolynomialMatrix (fz p) | |
| (informedWeight (keepZ p) (codeZ p)) | |
| refine ⟨MX, MY, MZ, ?_, ?_, ?_, ?_⟩ | |
| · intro p x u i | |
| exact weightedCoordinatePolynomialMatrix_degree _ _ x u i | |
| · intro p y v j | |
| exact weightedCoordinatePolynomialMatrix_degree _ _ y v j | |
| · intro p z w l | |
| exact weightedCoordinatePolynomialMatrix_degree _ _ z w l | |
| · intro p x y z h | |
| have codes := agree p x.1 y.1 z.1 h | |
| change kernel (auxiliaryXZ k) | |
| (weightedCoordinatePolynomialMatrix (fx p) (informedWeight (keepX p) (codeX p))) | |
| (weightedCoordinatePolynomialMatrix (fy p) (missingWeight (keepY p))) | |
| (weightedCoordinatePolynomialMatrix (fz p) (informedWeight (keepZ p) (codeZ p))) x y z = _ | |
| rw [kernel_weightedCoordinatePolynomialMatrix] | |
| dsimp only [fx, fy, fz, auxiliaryXZ] | |
| rw [← codes, coefficients] | |
| congr 1 | |
| unfold informedWeight missingWeight stageLeadingXZ stageLeading | |
| split_ifs <;> simp_all | |
| theorem exists_prefix_stage_YZ (k : ℕ) | |
| (codeY : Prefix → Y → Fin k) (codeZ : Prefix → Z → Fin k) | |
| (keepX : Prefix → X → Prop) (keepY : Prefix → Y → Prop) | |
| (keepZ : Prefix → Z → Prop) | |
| (eligible : Prefix → X → Y → Z → Prop) | |
| (agree : ∀ p x y z, eligible p x y z → codeY p y = codeZ p z) : | |
| ∃ (MX : Prefix → X → MissingOutput k → PoolAuxiliaryGroup k → Polynomial ℂ) | |
| (MY : Prefix → Y → InformedOutput k → PoolAuxiliaryGroup k → Polynomial ℂ) | |
| (MZ : Prefix → Z → InformedOutput k → PoolAuxiliaryGroup k → Polynomial ℂ), | |
| (∀ p x u i, (MX p x u i).degree ≤ (0 : ℕ)) ∧ | |
| (∀ p y v j, (MY p y v j).degree ≤ (0 : ℕ)) ∧ | |
| (∀ p z w l, (MZ p z w l).degree ≤ (0 : ℕ)) ∧ | |
| ∀ p x y z, eligible p x.1 y.1 z.1 → | |
| kernel (auxiliaryYZ k) (MX p) (MY p) (MZ p) x y z = | |
| Polynomial.C (stageLeadingYZ k codeY codeZ keepX keepY keepZ p x y z) := by | |
| classical | |
| obtain ⟨left, right, tag, coefficients⟩ := exists_auxiliary_coordinates k | |
| let fx : Prefix → X × MissingOutput k → PoolAuxiliaryGroup k := fun _ x => tag x.2.1 | |
| let fy : Prefix → Y × InformedOutput k → PoolAuxiliaryGroup k := | |
| fun p y => left (codeY p y.1) y.2.2 | |
| let fz : Prefix → Z × InformedOutput k → PoolAuxiliaryGroup k := | |
| fun p z => right (codeZ p z.1) z.2.2 | |
| let MX := fun p => weightedCoordinatePolynomialMatrix (fx p) (missingWeight (keepX p)) | |
| let MY := fun p => weightedCoordinatePolynomialMatrix (fy p) | |
| (informedWeight (keepY p) (codeY p)) | |
| let MZ := fun p => weightedCoordinatePolynomialMatrix (fz p) | |
| (informedWeight (keepZ p) (codeZ p)) | |
| refine ⟨MX, MY, MZ, ?_, ?_, ?_, ?_⟩ | |
| · intro p x u i | |
| exact weightedCoordinatePolynomialMatrix_degree _ _ x u i | |
| · intro p y v j | |
| exact weightedCoordinatePolynomialMatrix_degree _ _ y v j | |
| · intro p z w l | |
| exact weightedCoordinatePolynomialMatrix_degree _ _ z w l | |
| · intro p x y z h | |
| have codes := agree p x.1 y.1 z.1 h | |
| change kernel (auxiliaryYZ k) | |
| (weightedCoordinatePolynomialMatrix (fx p) (missingWeight (keepX p))) | |
| (weightedCoordinatePolynomialMatrix (fy p) (informedWeight (keepY p) (codeY p))) | |
| (weightedCoordinatePolynomialMatrix (fz p) (informedWeight (keepZ p) (codeZ p))) x y z = _ | |
| rw [kernel_weightedCoordinatePolynomialMatrix] | |
| dsimp only [fx, fy, fz, auxiliaryYZ] | |
| rw [← codes, coefficients] | |
| congr 1 | |
| unfold informedWeight missingWeight stageLeadingYZ stageLeading | |
| split_ifs <;> simp_all | |
| section RawPools | |
| variable {RawLabel : Type*} [DecidableEq RawLabel] | |
| def rawPoolLeadingXZ (pool : Prefix → Finset RawLabel) (k : ℕ) (positive : 0 < k) | |
| (counts : ∀ p, (pool p).card = k) | |
| (readX : Prefix → X → RawLabel) (readZ : Prefix → Z → RawLabel) (prior : Prefix) : | |
| Tensor ℂ (X × InformedOutput k) (Y × MissingOutput k) (Z × InformedOutput k) := | |
| fun x y z => rawPoolLeading pool k positive counts readX readZ prior x z y | |
| def rawPoolLeadingYZ (pool : Prefix → Finset RawLabel) (k : ℕ) (positive : 0 < k) | |
| (counts : ∀ p, (pool p).card = k) | |
| (readY : Prefix → Y → RawLabel) (readZ : Prefix → Z → RawLabel) (prior : Prefix) : | |
| Tensor ℂ (X × MissingOutput k) (Y × InformedOutput k) (Z × InformedOutput k) := | |
| fun x y z => rawPoolLeading pool k positive counts readY readZ prior y z x | |
| theorem exists_raw_pool_stage_XZ (pool : Prefix → Finset RawLabel) (k : ℕ) | |
| (positive : 0 < k) (counts : ∀ p, (pool p).card = k) | |
| (readX : Prefix → X → RawLabel) (readZ : Prefix → Z → RawLabel) | |
| (eligible : Prefix → X → Y → Z → Prop) | |
| (agree : ∀ p x y z, eligible p x y z → readX p x = readZ p z) : | |
| ∃ (MX : Prefix → X → InformedOutput k → PoolAuxiliaryGroup k → Polynomial ℂ) | |
| (MY : Prefix → Y → MissingOutput k → PoolAuxiliaryGroup k → Polynomial ℂ) | |
| (MZ : Prefix → Z → InformedOutput k → PoolAuxiliaryGroup k → Polynomial ℂ), | |
| (∀ p x u i, (MX p x u i).degree ≤ (0 : ℕ)) ∧ | |
| (∀ p y v j, (MY p y v j).degree ≤ (0 : ℕ)) ∧ | |
| (∀ p z w l, (MZ p z w l).degree ≤ (0 : ℕ)) ∧ | |
| ∀ p x y z, eligible p x.1 y.1 z.1 → | |
| kernel (auxiliaryXZ k) (MX p) (MY p) (MZ p) x y z = | |
| Polynomial.C (rawPoolLeadingXZ pool k positive counts readX readZ p x y z) := by | |
| apply exists_prefix_stage_XZ k | |
| (fun p x => maskedPoolCode pool k positive counts p (readX p x)) | |
| (fun p z => maskedPoolCode pool k positive counts p (readZ p z)) | |
| (fun p x => readX p x ∈ pool p) (fun _ _ => True) | |
| (fun p z => readZ p z ∈ pool p) eligible | |
| intro p x y z h | |
| exact congrArg (maskedPoolCode pool k positive counts p) (agree p x y z h) | |
| theorem exists_raw_pool_stage_YZ (pool : Prefix → Finset RawLabel) (k : ℕ) | |
| (positive : 0 < k) (counts : ∀ p, (pool p).card = k) | |
| (readY : Prefix → Y → RawLabel) (readZ : Prefix → Z → RawLabel) | |
| (eligible : Prefix → X → Y → Z → Prop) | |
| (agree : ∀ p x y z, eligible p x y z → readY p y = readZ p z) : | |
| ∃ (MX : Prefix → X → MissingOutput k → PoolAuxiliaryGroup k → Polynomial ℂ) | |
| (MY : Prefix → Y → InformedOutput k → PoolAuxiliaryGroup k → Polynomial ℂ) | |
| (MZ : Prefix → Z → InformedOutput k → PoolAuxiliaryGroup k → Polynomial ℂ), | |
| (∀ p x u i, (MX p x u i).degree ≤ (0 : ℕ)) ∧ | |
| (∀ p y v j, (MY p y v j).degree ≤ (0 : ℕ)) ∧ | |
| (∀ p z w l, (MZ p z w l).degree ≤ (0 : ℕ)) ∧ | |
| ∀ p x y z, eligible p x.1 y.1 z.1 → | |
| kernel (auxiliaryYZ k) (MX p) (MY p) (MZ p) x y z = | |
| Polynomial.C (rawPoolLeadingYZ pool k positive counts readY readZ p x y z) := by | |
| apply exists_prefix_stage_YZ k | |
| (fun p y => maskedPoolCode pool k positive counts p (readY p y)) | |
| (fun p z => maskedPoolCode pool k positive counts p (readZ p z)) | |
| (fun _ _ => True) (fun p y => readY p y ∈ pool p) | |
| (fun p z => readZ p z ∈ pool p) eligible | |
| intro p x y z h | |
| exact congrArg (maskedPoolCode pool k positive counts p) (agree p x y z h) | |
| end RawPools | |
| end MatrixMultiplication.Foundation.PrefixSeparationOrientations | |
| end | |
| end OAI | |