Download data/lean/OAI/LinearAlgebra/MatrixMultiplication/ComplexArithmetic/Growth.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 10.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/ComplexArithmetic/Growth.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/LinearAlgebra/MatrixMultiplication/ComplexArithmetic/Growth.lean
-
curl -L -o Growth.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/ComplexArithmetic/Growth.lean
10.4 kB
| import OAI.LinearAlgebra.MatrixMultiplication.ComplexArithmetic.Complexity | |
| import OAI.LinearAlgebra.MatrixMultiplication.ComplexArithmetic.MatrixPadding | |
| import OAI.LinearAlgebra.MatrixMultiplication.ComplexArithmetic.RecursiveBlockPrograms | |
| import Mathlib.Data.Nat.Log | |
| import Mathlib.Tactic.FieldSimp | |
| import Mathlib.Tactic.Linarith | |
| import Mathlib.Tactic.Ring | |
| import Lean.Elab.Tactic.Omega | |
| namespace OAI | |
| /-! Complex arithmetic programs and asymptotic matrix multiplication costs. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.Foundation.Arithmetic | |
| theorem exists_power_cover {b n : β} (hb : 2 β€ b) (hn : 1 β€ n) : | |
| β k : β, n β€ b ^ k β§ b ^ k β€ b * n := by | |
| refine β¨Nat.log b n + 1, (Nat.lt_pow_succ_log_self (by omega) n).le, ?_β© | |
| rw [pow_succ'] | |
| exact Nat.mul_le_mul_left b (Nat.pow_log_le_self b (by omega)) | |
| theorem geometric_cost_recurrence_bound (x : β β β) (a b d q : β) | |
| (hx : 0 β€ x 0) (ha : 0 β€ a) (hb : 0 β€ b) (hd : 0 β€ d) | |
| (haq : a < q) (hdq : d β€ q) | |
| (hstep : β k, x (k + 1) β€ a * x k + b * d ^ k) : | |
| β C : β, 0 < C β§ β k, x k β€ C * q ^ k := by | |
| let C := x 0 + b / (q - a) + 1 | |
| have hgap : 0 < q - a := sub_pos.mpr haq | |
| have hfrac : 0 β€ b / (q - a) := div_nonneg hb hgap.le | |
| have hC : 0 < C := by dsimp [C]; linarith | |
| have hcancel : (q - a) * (b / (q - a)) = b := by | |
| field_simp [ne_of_gt hgap] | |
| have hCfrac : b / (q - a) β€ C := by dsimp [C]; linarith | |
| have hcoeff : a * C + b β€ C * q := by | |
| have hmul := mul_le_mul_of_nonneg_left hCfrac hgap.le | |
| rw [hcancel] at hmul | |
| calc | |
| a * C + b β€ a * C + (q - a) * C := add_le_add_right hmul _ | |
| _ = C * q := by ring | |
| refine β¨C, hC, ?_β© | |
| intro k | |
| induction k with | |
| | zero => simp only [pow_zero, mul_one]; dsimp [C]; linarith | |
| | succ k ih => | |
| calc | |
| x (k + 1) β€ a * x k + b * d ^ k := hstep k | |
| _ β€ a * (C * q ^ k) + b * q ^ k := | |
| add_le_add (mul_le_mul_of_nonneg_left ih ha) | |
| (mul_le_mul_of_nonneg_left (pow_le_pow_leftβ hd hdq k) hb) | |
| _ = (a * C + b) * q ^ k := by ring | |
| _ β€ (C * q) * q ^ k := | |
| mul_le_mul_of_nonneg_right hcoeff (pow_nonneg (hd.trans hdq) k) | |
| _ = C * q ^ (k + 1) := by rw [pow_succ]; ring | |
| theorem power_cost_padding_bound | |
| (hpad : β {n m : β}, n β€ m β β P : MatrixAlgorithm m, P.Correct β | |
| β Q : MatrixAlgorithm n, Q.Correct β§ Q.cost β€ P.cost) | |
| {b : β} (hb : 2 β€ b) {s C : β} (hs : 0 β€ s) (hC : 0 < C) | |
| (hpower : β k : β, β P : MatrixAlgorithm (b ^ k), | |
| P.Correct β§ (P.cost : β) β€ C * ((b : β) ^ s) ^ k) : | |
| β D : β, 0 < D β§ β n : β, 1 β€ n β β P : MatrixAlgorithm n, | |
| P.Correct β§ (P.cost : β) β€ D * (n : β) ^ s := by | |
| have hbpos : 0 < (b : β) := by exact_mod_cast (by omega : 0 < b) | |
| refine β¨C * (b : β) ^ s, mul_pos hC (Real.rpow_pos_of_pos hbpos s), ?_β© | |
| intro n hn | |
| obtain β¨k, hnk, hknβ© := exists_power_cover hb hn | |
| obtain β¨P, hP, hcostβ© := hpower k | |
| obtain β¨Q, hQ, hQPβ© := hpad hnk P hP | |
| refine β¨Q, hQ, ?_β© | |
| calc | |
| (Q.cost : β) β€ (P.cost : β) := by exact_mod_cast hQP | |
| _ β€ C * ((b : β) ^ s) ^ k := hcost | |
| _ = C * ((b ^ k : β) : β) ^ s := by | |
| rw [Real.rpow_pow_comm hbpos.le, Nat.cast_pow] | |
| _ β€ C * ((b : β) * (n : β)) ^ s := | |
| mul_le_mul_of_nonneg_left | |
| (Real.rpow_le_rpow (Nat.cast_nonneg _) (by exact_mod_cast hkn) hs) hC.le | |
| _ = (C * (b : β) ^ s) * (n : β) ^ s := by | |
| rw [Real.mul_rpow hbpos.le (Nat.cast_nonneg n)] | |
| ring | |
| theorem admissibleExponent_of_uniform_power_costs | |
| (hpad : β {n m : β}, n β€ m β β P : MatrixAlgorithm m, P.Correct β | |
| β Q : MatrixAlgorithm n, Q.Correct β§ Q.cost β€ P.cost) | |
| {b : β} (hb : 2 β€ b) {Ο C : β} (hΟ : 0 β€ Ο) (hC : 0 < C) | |
| (hpower : β k : β, β P : MatrixAlgorithm (b ^ k), | |
| P.Correct β§ (P.cost : β) β€ C * ((b : β) ^ Ο) ^ k) : | |
| AdmissibleExponent Ο := by | |
| obtain β¨D, hD, hallβ© := power_cost_padding_bound hpad hb hΟ hC hpower | |
| intro Ξ΅ hΞ΅ | |
| refine β¨D, hD, ?_β© | |
| intro n hn | |
| obtain β¨P, hP, hcostβ© := hall n hn | |
| refine β¨P, hP, hcost.trans ?_β© | |
| exact mul_le_mul_of_nonneg_left | |
| (Real.rpow_le_rpow_of_exponent_le (by exact_mod_cast hn) (by linarith)) hD.le | |
| theorem admissibleExponent_of_power_costs | |
| (hpad : β {n m : β}, n β€ m β β P : MatrixAlgorithm m, P.Correct β | |
| β Q : MatrixAlgorithm n, Q.Correct β§ Q.cost β€ P.cost) | |
| {b : β} (hb : 2 β€ b) {Ο : β} (hΟ : 0 β€ Ο) | |
| (hpower : β Ξ΅ : β, 0 < Ξ΅ β β C : β, 0 < C β§ | |
| β k : β, β P : MatrixAlgorithm (b ^ k), | |
| P.Correct β§ (P.cost : β) β€ C * ((b : β) ^ (Ο + Ξ΅)) ^ k) : | |
| AdmissibleExponent Ο := by | |
| intro Ξ΅ hΞ΅ | |
| obtain β¨C, hC, hcostβ© := hpower Ξ΅ hΞ΅ | |
| exact power_cost_padding_bound hpad hb (by linarith) hC hcost | |
| theorem admissibleExponent_of_recursive_costs | |
| (hpad : β {n m : β}, n β€ m β β P : MatrixAlgorithm m, P.Correct β | |
| β Q : MatrixAlgorithm n, Q.Correct β§ Q.cost β€ P.cost) | |
| {b R K : β} (hb : 2 β€ b) {Ο : β} (hΟ : 2 β€ Ο) | |
| (hR : (R : β) β€ (b : β) ^ Ο) | |
| (P : β k : β, MatrixAlgorithm (b ^ k)) | |
| (hP : β k, (P k).Correct) | |
| (hstep : β k, (P (k + 1)).cost β€ R * (P k).cost + K * (b ^ k) ^ 2) : | |
| AdmissibleExponent Ο := by | |
| apply admissibleExponent_of_power_costs hpad hb (by linarith) | |
| intro Ξ΅ hΞ΅ | |
| have hbpos : 0 < (b : β) := by exact_mod_cast (by omega : 0 < b) | |
| have hbone : 1 < (b : β) := by exact_mod_cast (by omega : 1 < b) | |
| have hrate : (R : β) < (b : β) ^ (Ο + Ξ΅) := | |
| hR.trans_lt (Real.rpow_lt_rpow_of_exponent_lt hbone (by linarith)) | |
| have hquad : (b : β) ^ (2 : β) β€ (b : β) ^ (Ο + Ξ΅) := by | |
| rw [β Real.rpow_natCast] | |
| change (b : β) ^ (2 : β) β€ (b : β) ^ (Ο + Ξ΅) | |
| exact Real.rpow_le_rpow_of_exponent_le hbone.le (by linarith) | |
| obtain β¨C, hC, hboundβ© := geometric_cost_recurrence_bound | |
| (fun k => ((P k).cost : β)) (R : β) (K : β) ((b : β) ^ (2 : β)) | |
| ((b : β) ^ (Ο + Ξ΅)) (Nat.cast_nonneg _) (Nat.cast_nonneg _) | |
| (Nat.cast_nonneg _) (sq_nonneg _) hrate hquad (fun k => by | |
| have h := hstep k | |
| have hcast : ((P (k + 1)).cost : β) β€ | |
| (R : β) * ((P k).cost : β) + (K : β) * ((b : β) ^ k) ^ 2 := by | |
| exact_mod_cast h | |
| simpa only [β pow_mul, Nat.mul_comm k 2] using hcast) | |
| exact β¨C, hC, fun k => β¨P k, hP k, hbound kβ©β© | |
| def blockRecurrenceCost (b R K : β) : β β β | |
| | 0 => 1 | |
| | k + 1 => R * blockRecurrenceCost b R K k + K * (b ^ k) ^ 2 | |
| @[simp] theorem blockRecurrenceCost_zero (b R K : β) : | |
| blockRecurrenceCost b R K 0 = 1 := rfl | |
| @[simp] theorem blockRecurrenceCost_succ (b R K k : β) : | |
| blockRecurrenceCost b R K (k + 1) = | |
| R * blockRecurrenceCost b R K k + K * (b ^ k) ^ 2 := rfl | |
| theorem power_programs_of_block_step {b R K : β} | |
| (hstep : β m : β, β P : MatrixAlgorithm m, P.Correct β | |
| β Q : MatrixAlgorithm (b * m), Q.Correct β§ | |
| Q.cost β€ R * P.cost + K * m ^ 2) : | |
| β k : β, β P : MatrixAlgorithm (b ^ k), P.Correct β§ | |
| P.cost β€ blockRecurrenceCost b R K k := by | |
| intro k | |
| induction k with | |
| | zero => | |
| exact β¨scalarAlgorithm, scalarAlgorithm_correct, by simpβ© | |
| | succ k ih => | |
| obtain β¨P, hP, hcostβ© := ih | |
| obtain β¨Q, hQ, hQcostβ© := hstep (b ^ k) P hP | |
| have hbound : Q.cost β€ blockRecurrenceCost b R K (k + 1) := by | |
| exact hQcost.trans (Nat.add_le_add_right (Nat.mul_le_mul_left R hcost) _) | |
| have hresult : β Q : MatrixAlgorithm (b * b ^ k), Q.Correct β§ | |
| Q.cost β€ blockRecurrenceCost b R K (k + 1) := β¨Q, hQ, hboundβ© | |
| exact (pow_succ' b k).symm βΈ hresult | |
| theorem admissibleExponent_of_block_step_of_padding | |
| (hpad : β {n m : β}, n β€ m β β P : MatrixAlgorithm m, P.Correct β | |
| β Q : MatrixAlgorithm n, Q.Correct β§ Q.cost β€ P.cost) | |
| {b R K : β} (hb : 2 β€ b) {Ο : β} (hΟ : 2 β€ Ο) | |
| (hR : (R : β) β€ (b : β) ^ Ο) | |
| (hstep : β m : β, β P : MatrixAlgorithm m, P.Correct β | |
| β Q : MatrixAlgorithm (b * m), Q.Correct β§ | |
| Q.cost β€ R * P.cost + K * m ^ 2) : | |
| AdmissibleExponent Ο := by | |
| apply admissibleExponent_of_power_costs hpad hb (by linarith) | |
| intro Ξ΅ hΞ΅ | |
| have hbone : 1 < (b : β) := by exact_mod_cast (by omega : 1 < b) | |
| have hrate : (R : β) < (b : β) ^ (Ο + Ξ΅) := | |
| hR.trans_lt (Real.rpow_lt_rpow_of_exponent_lt hbone (by linarith)) | |
| have hquad : (b : β) ^ (2 : β) β€ (b : β) ^ (Ο + Ξ΅) := by | |
| rw [β Real.rpow_natCast] | |
| change (b : β) ^ (2 : β) β€ (b : β) ^ (Ο + Ξ΅) | |
| exact Real.rpow_le_rpow_of_exponent_le hbone.le (by linarith) | |
| obtain β¨C, hC, hboundβ© := geometric_cost_recurrence_bound | |
| (fun k => (blockRecurrenceCost b R K k : β)) | |
| (R : β) (K : β) ((b : β) ^ (2 : β)) ((b : β) ^ (Ο + Ξ΅)) | |
| (Nat.cast_nonneg _) (Nat.cast_nonneg _) (Nat.cast_nonneg _) | |
| (sq_nonneg _) hrate hquad (fun k => by | |
| simp only [blockRecurrenceCost_succ, Nat.cast_add, Nat.cast_mul, Nat.cast_pow] | |
| rw [β pow_mul, β pow_mul, Nat.mul_comm k 2]) | |
| refine β¨C, hC, ?_β© | |
| intro k | |
| obtain β¨P, hP, hcostβ© := power_programs_of_block_step hstep k | |
| exact β¨P, hP, (by exact_mod_cast hcost : (P.cost : β) β€ | |
| (blockRecurrenceCost b R K k : β)).trans (hbound k)β© | |
| theorem admissibleExponent_of_block_step | |
| {b R K : β} (hb : 2 β€ b) {Ο : β} (hΟ : 2 β€ Ο) | |
| (hR : (R : β) β€ (b : β) ^ Ο) | |
| (hstep : β m : β, β P : MatrixAlgorithm m, P.Correct β | |
| β Q : MatrixAlgorithm (b * m), Q.Correct β§ | |
| Q.cost β€ R * P.cost + K * m ^ 2) : | |
| AdmissibleExponent Ο := | |
| admissibleExponent_of_block_step_of_padding | |
| (fun h P hP => MatrixAlgorithm.exists_restrict h P hP) hb hΟ hR hstep | |
| theorem admissibleExponent_of_rankAtMost {n R : β} (hn : 2 β€ n) | |
| (hRank : Tensor.RankAtMost (Tensor.matrixMultiplication n n n) R) | |
| {Ο : β} (hΟ : 2 β€ Ο) (hR : (R : β) β€ (n : β) ^ Ο) : | |
| AdmissibleExponent Ο := by | |
| apply admissibleExponent_of_block_step (K := 6 * R * n ^ 2) hn hΟ hR | |
| intro m P hP | |
| obtain β¨Q, hQ, hcostβ© := RecursiveBlock.rank_block_step hRank P hP | |
| exact β¨Q, hQ, hcost.leβ© | |
| end MatrixMultiplication.Foundation.Arithmetic | |
| end | |
| end OAI | |