openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Separation /ComplexBalancedSeparation.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Tensor.ComplexPairingMatrixTensor | |
| import OAI.LinearAlgebra.MatrixMultiplication.Entropy.ComplexHierarchySeparationRates | |
| import OAI.LinearAlgebra.MatrixMultiplication.Entropy.ComplexOrientationRates | |
| namespace OAI | |
| /-! Finite type counts, hierarchy separation and tensor execution bounds. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.Foundation.BalancedSeparation | |
| open scoped BigOperators | |
| open Tensor LabelHierarchySeparation OrientationRates | |
| section SinglePool | |
| def singlePairingX (k : ℕ) : (Fin 1 × Fin k) ≃ Fin k where | |
| toFun x := x.2 | |
| invFun x := (0, x) | |
| left_inv _ := Prod.ext (Subsingleton.elim _ _) rfl | |
| right_inv _ := rfl | |
| def singlePairingY (k : ℕ) : (Fin k × Fin 1) ≃ Fin k where | |
| toFun y := y.1 | |
| invFun y := (y, 0) | |
| left_inv _ := Prod.ext rfl (Subsingleton.elim _ _) | |
| right_inv _ := rfl | |
| def singlePairingZ : (Fin 1 × Fin 1) ≃ Unit where | |
| toFun _ := () | |
| invFun _ := (0, 0) | |
| left_inv _ := Subsingleton.elim _ _ | |
| right_inv _ := Subsingleton.elim _ _ | |
| theorem singlePairing_matrix (k : ℕ) : | |
| pullback (singlePairingX k) (singlePairingY k) singlePairingZ | |
| (dotPairing (K := ℂ) (Fin k)) = | |
| matrixCoefficients (Fin 1) (Fin k) (Fin 1) := by | |
| funext x y z | |
| have hyz : y.2 = z.1 := Subsingleton.elim _ _ | |
| have hzx : z.2 = x.1 := Subsingleton.elim _ _ | |
| change (if x.2 = y.1 then (1 : ℂ) else 0) = | |
| if x.2 = y.1 ∧ y.2 = z.1 ∧ z.2 = x.1 then 1 else 0 | |
| simp only [hyz, hzx, and_true] | |
| theorem singlePairingXZ_matrix (k : ℕ) : | |
| pullback (singlePairingY k) singlePairingZ (singlePairingX k) | |
| (cyclic (dotPairing (K := ℂ) (Fin k))) = | |
| matrixCoefficients (Fin k) (Fin 1) (Fin 1) := by | |
| funext x y z | |
| have hxy : x.2 = y.1 := Subsingleton.elim _ _ | |
| have hyz : y.2 = z.1 := Subsingleton.elim _ _ | |
| change (if z.2 = x.1 then (1 : ℂ) else 0) = | |
| if x.2 = y.1 ∧ y.2 = z.1 ∧ z.2 = x.1 then 1 else 0 | |
| simp only [hxy, hyz, true_and] | |
| theorem singlePairingYZ_matrix (k : ℕ) : | |
| pullback singlePairingZ (singlePairingX k) (singlePairingY k) | |
| (cyclic (cyclic (dotPairing (K := ℂ) (Fin k)))) = | |
| matrixCoefficients (Fin 1) (Fin 1) (Fin k) := by | |
| funext x y z | |
| have hxy : x.2 = y.1 := Subsingleton.elim _ _ | |
| have hzx : z.2 = x.1 := Subsingleton.elim _ _ | |
| change (if y.2 = z.1 then (1 : ℂ) else 0) = | |
| if x.2 = y.1 ∧ y.2 = z.1 ∧ z.2 = x.1 then 1 else 0 | |
| simp only [hxy, hzx, true_and, and_true] | |
| theorem singlePairing_budget (k : ℕ) : 1 * k * 1 ≤ poolAuxiliaryCost k := by | |
| simpa only [one_mul, mul_one] using population_le_poolAuxiliaryCost k | |
| end SinglePool | |
| section MatrixBank | |
| variable {K I : Type*} [CommSemiring K] [Fintype I] [DecidableEq I] | |
| variable {A B C : I → Type*} | |
| variable [∀ i, DecidableEq (A i)] [∀ i, DecidableEq (B i)] [∀ i, DecidableEq (C i)] | |
| def piPairEquiv (A B : I → Type*) : | |
| ((∀ i, A i) × (∀ i, B i)) ≃ (∀ i, A i × B i) where | |
| toFun x i := (x.1 i, x.2 i) | |
| invFun x := (fun i => (x i).1, fun i => (x i).2) | |
| left_inv _ := rfl | |
| right_inv _ := rfl | |
| omit [DecidableEq I] in | |
| theorem matrixBank_identity : | |
| pullback (piPairEquiv A B) (piPairEquiv B C) (piPairEquiv C A) | |
| (bankTensor (fun i => matrixCoefficients (K := K) (A i) (B i) (C i))) = | |
| matrixCoefficients (∀ i, A i) (∀ i, B i) (∀ i, C i) := by | |
| funext x y z | |
| change (∏ i, if x.2 i = y.1 i ∧ y.2 i = z.1 i ∧ z.2 i = x.1 i then (1 : K) else 0) = | |
| if x.2 = y.1 ∧ y.2 = z.1 ∧ z.2 = x.1 then 1 else 0 | |
| simp only [Fintype.prod_boole, forall_and, ← funext_iff] | |
| end MatrixBank | |
| section PoolDimensions | |
| variable {I : Type*} [Fintype I] [DecidableEq I] | |
| def factorDimension (slot : I → Fin 3) (k : I → ℕ) (i : I) (s : Fin 3) : ℕ := | |
| if slot i = s then k i else 1 | |
| def bankDimension (slot : I → Fin 3) (k : I → ℕ) (s : Fin 3) : ℕ := | |
| ∏ i, factorDimension slot k i s | |
| abbrev BankIndex (slot : I → Fin 3) (k : I → ℕ) (s : Fin 3) := | |
| ∀ i, Fin (factorDimension slot k i s) | |
| theorem card_BankIndex (slot : I → Fin 3) (k : I → ℕ) (s : Fin 3) : | |
| Fintype.card (BankIndex slot k s) = bankDimension slot k s := by | |
| simp only [BankIndex, Fintype.card_pi, Fintype.card_fin, bankDimension] | |
| def bankIndexFinEquiv (slot : I → Fin 3) (k : I → ℕ) (s : Fin 3) : | |
| Fin (bankDimension slot k s) ≃ BankIndex slot k s := | |
| (Fintype.equivFinOfCardEq (card_BankIndex slot k s)).symm | |
| omit [DecidableEq I] in | |
| theorem bank_volume (slot : I → Fin 3) (k : I → ℕ) : | |
| bankDimension slot k 0 * bankDimension slot k 1 * bankDimension slot k 2 = | |
| ∏ i, k i := by | |
| rw [← Fin.prod_univ_three (bankDimension slot k)] | |
| unfold bankDimension | |
| rw [Finset.prod_comm] | |
| apply Finset.prod_congr rfl | |
| intro i hi | |
| simp [factorDimension] | |
| omit [DecidableEq I] in | |
| theorem bankDimension_pos (slot : I → Fin 3) (k : I → ℕ) | |
| (positive : ∀ i, 0 < k i) (s : Fin 3) : 0 < bankDimension slot k s := by | |
| apply Finset.prod_pos | |
| intro i hi | |
| unfold factorDimension | |
| split_ifs | |
| · exact positive i | |
| · exact Nat.zero_lt_one | |
| omit [DecidableEq I] in | |
| theorem bank_volume_le_auxiliary (slot : I → Fin 3) (k : I → ℕ) : | |
| bankDimension slot k 0 * bankDimension slot k 1 * bankDimension slot k 2 ≤ | |
| ∏ i, poolAuxiliaryCost (k i) := by | |
| rw [bank_volume] | |
| exact Finset.prod_le_prod (fun i _ => population_le_poolAuxiliaryCost (k i)) | |
| def bankMatrixCoordinate (slot : I → Fin 3) (k : I → ℕ) (s t : Fin 3) : | |
| (Fin (bankDimension slot k s) × Fin (bankDimension slot k t)) ≃ | |
| (∀ i, Fin (factorDimension slot k i s) × Fin (factorDimension slot k i t)) := | |
| (Equiv.prodCongr (bankIndexFinEquiv slot k s) (bankIndexFinEquiv slot k t)).trans | |
| (piPairEquiv _ _) | |
| def matrixBank (slot : I → Fin 3) (k : I → ℕ) := | |
| bankTensor (fun i => matrixCoefficients (K := ℂ) | |
| (Fin (factorDimension slot k i 0)) (Fin (factorDimension slot k i 1)) | |
| (Fin (factorDimension slot k i 2))) | |
| theorem matrixBank_numeric (slot : I → Fin 3) (k : I → ℕ) : | |
| pullback (bankMatrixCoordinate slot k 0 1) (bankMatrixCoordinate slot k 1 2) | |
| (bankMatrixCoordinate slot k 2 0) (matrixBank slot k) = | |
| matrixCoefficients (Fin (bankDimension slot k 0)) | |
| (Fin (bankDimension slot k 1)) (Fin (bankDimension slot k 2)) := by | |
| have h := matrixBank_identity (K := ℂ) | |
| (A := fun i => Fin (factorDimension slot k i 0)) | |
| (B := fun i => Fin (factorDimension slot k i 1)) | |
| (C := fun i => Fin (factorDimension slot k i 2)) | |
| funext x y z | |
| have he := congrFun (congrFun (congrFun h | |
| (bankIndexFinEquiv slot k 0 x.1, bankIndexFinEquiv slot k 1 x.2)) | |
| (bankIndexFinEquiv slot k 1 y.1, bankIndexFinEquiv slot k 2 y.2)) | |
| (bankIndexFinEquiv slot k 2 z.1, bankIndexFinEquiv slot k 0 z.2) | |
| simpa only [pullback, matrixBank, bankMatrixCoordinate, Equiv.trans_apply, | |
| Equiv.prodCongr_apply, piPairEquiv, Equiv.coe_fn_mk, Prod.map_fst, Prod.map_snd, | |
| matrixCoefficients, Equiv.apply_eq_iff_eq] using he | |
| def orientedPairingBank (slot : I → Fin 3) (k : I → ℕ) := | |
| bankTensor (fun i => pairingTriple (K := ℂ) | |
| (Fin (factorDimension slot k i 0)) (Fin (factorDimension slot k i 1)) | |
| (Fin (factorDimension slot k i 2))) | |
| def pairingBankX (slot : I → Fin 3) (k : I → ℕ) := | |
| (bankMatrixCoordinate slot k 0 1).trans | |
| (Equiv.piCongrRight fun i => pairingTripleMatrixX | |
| (Fin (factorDimension slot k i 0)) (Fin (factorDimension slot k i 1))) | |
| def pairingBankY (slot : I → Fin 3) (k : I → ℕ) := | |
| (bankMatrixCoordinate slot k 1 2).trans | |
| (Equiv.piCongrRight fun i => pairingTripleMatrixY | |
| (Fin (factorDimension slot k i 1)) (Fin (factorDimension slot k i 2))) | |
| def pairingBankZ (slot : I → Fin 3) (k : I → ℕ) := | |
| (bankMatrixCoordinate slot k 2 0).trans | |
| (Equiv.piCongrRight fun i => pairingTripleMatrixZ | |
| (Fin (factorDimension slot k i 2)) (Fin (factorDimension slot k i 0))) | |
| theorem orientedPairingBank_numeric (slot : I → Fin 3) (k : I → ℕ) : | |
| pullback (pairingBankX slot k) (pairingBankY slot k) (pairingBankZ slot k) | |
| (orientedPairingBank slot k) = | |
| matrixCoefficients (Fin (bankDimension slot k 0)) | |
| (Fin (bankDimension slot k 1)) (Fin (bankDimension slot k 2)) := by | |
| rw [← matrixBank_numeric slot k] | |
| funext x y z | |
| apply Finset.prod_congr rfl | |
| intro i hi | |
| exact congrFun (congrFun (congrFun | |
| (pairingTriple_matrixCoefficients (K := ℂ) | |
| (A := Fin (factorDimension slot k i 0)) | |
| (B := Fin (factorDimension slot k i 1)) | |
| (C := Fin (factorDimension slot k i 2))) | |
| (bankMatrixCoordinate slot k 0 1 x i)) | |
| (bankMatrixCoordinate slot k 1 2 y i)) | |
| (bankMatrixCoordinate slot k 2 0 z i) | |
| theorem orientedPairingBank_directSum_rank {Label : Type*} [DecidableEq Label] | |
| (slot : I → Fin 3) (k : I → ℕ) {r : ℕ} | |
| (h : RankAtMost (directSum (fun _ : Label => orientedPairingBank slot k)) r) : | |
| RankAtMost (directSum (fun _ : Label => | |
| matrixCoefficients (K := ℂ) (Fin (bankDimension slot k 0)) | |
| (Fin (bankDimension slot k 1)) (Fin (bankDimension slot k 2)))) r := by | |
| have hp := h.directSum_pullback (pairingBankX slot k) (pairingBankY slot k) | |
| (pairingBankZ slot k) | |
| simpa only [orientedPairingBank_numeric] using hp | |
| theorem orientedPairingBank_directSum_borderRank {Label : Type*} | |
| [Fintype Label] [DecidableEq Label] | |
| (slot : I → Fin 3) (k : I → ℕ) {r : ℕ} | |
| (h : BorderRankAtMost | |
| (directSum (fun _ : Label => orientedPairingBank slot k)) r) : | |
| BorderRankAtMost (directSum (fun _ : Label => | |
| matrixCoefficients (K := ℂ) (Fin (bankDimension slot k 0)) | |
| (Fin (bankDimension slot k 1)) (Fin (bankDimension slot k 2)))) r := by | |
| classical | |
| have heq := directSum_pullback (fun _ : Label => orientedPairingBank slot k) | |
| (pairingBankX slot k) (pairingBankY slot k) (pairingBankZ slot k) | |
| simp only [orientedPairingBank_numeric] at heq | |
| rw [← heq, pullback_eq_restrict] | |
| exact h.restrict _ _ _ | |
| end PoolDimensions | |
| section SixOrientations | |
| variable {I : Type*} [Fintype I] [DecidableEq I] | |
| def physicalPairingSlot (orientation : Orientation) : Fin 3 := | |
| if orientation 1 = 2 then 0 else if orientation 2 = 2 then 1 else 2 | |
| theorem physicalPairingSlot_fiber_card : ∀ s : Fin 3, | |
| Fintype.card {orientation : Orientation // physicalPairingSlot orientation = s} = 2 := by | |
| decide | |
| theorem physicalPairingSlot_product (k : ℕ) (s : Fin 3) : | |
| (∏ orientation : Orientation, if physicalPairingSlot orientation = s then k else 1) = | |
| k ^ 2 := by | |
| rw [← Finset.prod_filter] | |
| rw [Finset.prod_const] | |
| have h := physicalPairingSlot_fiber_card s | |
| rw [Fintype.card_subtype] at h | |
| rw [h] | |
| def sixSlot (relative : I → Orientation) (i : Orientation × I) : Fin 3 := | |
| physicalPairingSlot (i.1 * relative i.2) | |
| omit [DecidableEq I] in | |
| theorem six_bankDimension (relative : I → Orientation) (k : I → ℕ) (s : Fin 3) : | |
| bankDimension (sixSlot relative) (fun i : Orientation × I => k i.2) s = | |
| (∏ i, k i) ^ 2 := by | |
| unfold bankDimension factorDimension sixSlot | |
| rw [Fintype.prod_prod_type, Finset.prod_comm] | |
| calc | |
| _ = ∏ i, (k i) ^ 2 := by | |
| apply Finset.prod_congr rfl | |
| intro i _ | |
| calc | |
| _ = ∏ orientation : Orientation, | |
| if physicalPairingSlot orientation = s then k i else 1 := | |
| prod_relative_orientation (relative i) | |
| (fun orientation => if physicalPairingSlot orientation = s then k i else 1) | |
| _ = _ := physicalPairingSlot_product (k i) s | |
| _ = _ := Finset.prod_pow _ _ _ | |
| omit [DecidableEq I] in | |
| theorem six_bank_volume (relative : I → Orientation) (k : I → ℕ) : | |
| bankDimension (sixSlot relative) (fun i : Orientation × I => k i.2) 0 * | |
| bankDimension (sixSlot relative) (fun i : Orientation × I => k i.2) 1 * | |
| bankDimension (sixSlot relative) (fun i : Orientation × I => k i.2) 2 = | |
| (∏ i, k i) ^ 6 := by | |
| rw [six_bankDimension, six_bankDimension, six_bankDimension] | |
| ring | |
| omit [DecidableEq I] in | |
| theorem six_bank_budget (k : I → ℕ) : | |
| (∏ i, k i) ^ 6 ≤ (∏ i, poolAuxiliaryCost (k i)) ^ 6 := by | |
| exact pow_le_pow_left' | |
| (Finset.prod_le_prod (fun i _ => population_le_poolAuxiliaryCost (k i))) 6 | |
| omit [DecidableEq I] in | |
| theorem six_auxiliary_product (k : I → ℕ) : | |
| (∏ i : Orientation × I, poolAuxiliaryCost (k i.2)) = | |
| (∏ i, poolAuxiliaryCost (k i)) ^ 6 := by | |
| rw [Fintype.prod_prod_type] | |
| simp only [Finset.prod_const, Finset.card_univ, orientation_card] | |
| def orientationBankEquiv (relative : I → Orientation) : | |
| (Orientation × I) ≃ (Orientation × I) where | |
| toFun x := (x.1 * relative x.2, x.2) | |
| invFun x := (x.1 * (relative x.2)⁻¹, x.2) | |
| left_inv x := by simp [mul_assoc] | |
| right_inv x := by simp [mul_assoc] | |
| omit [Fintype I] [DecidableEq I] in | |
| @[simp] theorem orientationBankEquiv_site (relative : I → Orientation) | |
| (x : Orientation × I) : (orientationBankEquiv relative x).2 = x.2 := rfl | |
| def orientationCoordinateEquiv (relative : I → Orientation) (F : Type*) : | |
| ((Orientation × I) → F) ≃ ((Orientation × I) → F) where | |
| toFun word site := word (orientationBankEquiv relative site) | |
| invFun word site := word ((orientationBankEquiv relative).symm site) | |
| left_inv word := by | |
| funext site | |
| simp | |
| right_inv word := by | |
| funext site | |
| simp | |
| omit [DecidableEq I] in | |
| theorem orientationCoordinateEquiv_tensor {K X Y Z : Type*} [CommSemiring K] | |
| (relative : I → Orientation) (T : Tensor K X Y Z) : | |
| pullback (orientationCoordinateEquiv relative X) | |
| (orientationCoordinateEquiv relative Y) (orientationCoordinateEquiv relative Z) | |
| (bankTensor (fun _ : Orientation × I => T)) = | |
| bankTensor (fun _ : Orientation × I => T) := by | |
| funext x y z | |
| exact (orientationBankEquiv relative).prod_comp (fun site => T (x site) (y site) (z site)) | |
| omit [DecidableEq I] in | |
| theorem orientationBankEquiv_grade_card {Grade : Type*} [DecidableEq Grade] | |
| (relative : I → Orientation) (word : Orientation × I → Grade) | |
| (orientation : Orientation) (grade : Grade) : | |
| Fintype.card {x : Orientation × I // | |
| (orientationBankEquiv relative x).1 = orientation ∧ | |
| word (orientationBankEquiv relative x) = grade} = | |
| Fintype.card {x : Orientation × I // x.1 = orientation ∧ word x = grade} := | |
| Fintype.card_congr ((orientationBankEquiv relative).subtypeEquiv fun _ => Iff.rfl) | |
| end SixOrientations | |
| end MatrixMultiplication.Foundation.BalancedSeparation | |
| end | |
| end OAI | |