| import Mathlib |
| import OAI.LinearAlgebra.MatrixFields.Extraction.ConstructionLabels |
|
|
| namespace OAI |
|
|
| namespace MatrixAllFields |
|
|
| open scoped BigOperators Topology Polynomial |
|
|
| noncomputable section |
|
|
| namespace MatrixMultiplication.AllFieldSourceRates |
|
|
| open AllFieldSource Filter |
| open scoped Topology |
|
|
| private theorem tendsto_log_linear_div_nat (a : ℝ) (ha : 0 < a) : |
| Tendsto (fun N : ℕ => Real.log (a * N + 1) / (N : ℝ)) atTop (𝓝 0) := by |
| have hnat : Tendsto (fun N : ℕ => (N : ℝ)) atTop atTop := |
| tendsto_natCast_atTop_atTop |
| have harg : Tendsto (fun N : ℕ => a * N + 1) atTop atTop := |
| (hnat.const_mul_atTop ha).atTop_add_nonneg (fun _ => zero_le_one) |
| have hlog : Tendsto (fun N : ℕ => Real.log (a * N + 1) / (a * N + 1)) |
| atTop (𝓝 0) := by |
| simpa only [Function.comp_def, id_eq] using |
| Real.isLittleO_log_id_atTop.tendsto_div_nhds_zero.comp harg |
| have hinv : Tendsto (fun N : ℕ => (1 : ℝ) / N) atTop (𝓝 0) := |
| tendsto_const_nhds.div_atTop hnat |
| have hratio : Tendsto (fun N : ℕ => (a * N + 1) / (N : ℝ)) atTop (𝓝 a) := by |
| have hsum : Tendsto (fun N : ℕ => a + 1 / (N : ℝ)) atTop (𝓝 a) := by |
| simpa only [add_zero] using hinv.const_add a |
| apply hsum.congr' |
| filter_upwards [eventually_ne_atTop (0 : ℕ)] with N hN |
| have hN' : (N : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hN |
| field_simp [hN'] |
| have hprod : Tendsto (fun N : ℕ => |
| (Real.log (a * N + 1) / (a * N + 1)) * ((a * N + 1) / (N : ℝ))) |
| atTop (𝓝 0) := by |
| simpa only [zero_mul] using hlog.mul hratio |
| apply hprod.congr |
| intro N |
| have harg' : a * (N : ℝ) + 1 ≠ 0 := by positivity |
| exact div_mul_div_cancel₀ harg' |
|
|
| theorem tendsto_log_polynomial_overhead (K : ℕ) (hK : 0 < K) : |
| Tendsto (fun N : ℕ => |
| Real.log (((3 * (8 * K * N) + 1) ^ 2 : ℕ) : ℝ) / ((K : ℝ) * N)) |
| atTop (𝓝 0) := by |
| have hK' : (0 : ℝ) < K := Nat.cast_pos.mpr hK |
| have hbase := tendsto_log_linear_div_nat (3 * (8 * (K : ℝ))) (by positivity) |
| have hscaled : Tendsto (fun N : ℕ => |
| (2 * (Real.log (3 * (8 * (K : ℝ)) * N + 1) / (N : ℝ))) / (K : ℝ)) |
| atTop (𝓝 0) := by |
| simpa only [mul_zero, zero_div] using (hbase.const_mul 2).div_const (K : ℝ) |
| apply hscaled.congr |
| intro N |
| have harg : ((3 * (8 * K * N) + 1 : ℕ) : ℝ) = |
| 3 * (8 * (K : ℝ)) * N + 1 := by push_cast; ring |
| rw [Nat.cast_pow, Real.log_pow, harg] |
| norm_num only [Nat.cast_ofNat] |
| ring |
|
|
| theorem tendsto_log_exponential_source (K : ℕ) (hK : 0 < K) : |
| Tendsto (fun N : ℕ => |
| Real.log ((7 ^ (8 * K * N) : ℕ) : ℝ) / ((K : ℝ) * N)) |
| atTop (𝓝 (8 * Real.log 7)) := by |
| have hK' : (K : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr (Nat.ne_of_gt hK) |
| apply tendsto_const_nhds.congr' |
| filter_upwards [eventually_ne_atTop (0 : ℕ)] with N hN |
| have hN' : (N : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hN |
| rw [Nat.cast_pow, Real.log_pow] |
| push_cast |
| field_simp [hK', hN'] |
|
|
| theorem log_rankBudget (Copies : Type*) [Fintype Copies] (K N : ℕ) |
| (hcopies : 0 < Fintype.card Copies) : |
| Real.log (rankBudget Copies K N : ℝ) = |
| Real.log (Fintype.card Copies : ℝ) + |
| Real.log (((3 * (8 * K * N) + 1) ^ 2 : ℕ) : ℝ) + |
| Real.log ((7 ^ (8 * K * N) : ℕ) : ℝ) := by |
| have hc : (Fintype.card Copies : ℝ) ≠ 0 := |
| Nat.cast_ne_zero.mpr (Nat.ne_of_gt hcopies) |
| have hp : (((3 * (8 * K * N) + 1) ^ 2 : ℕ) : ℝ) ≠ 0 := by positivity |
| have he : ((7 ^ (8 * K * N) : ℕ) : ℝ) ≠ 0 := by positivity |
| simp only [rankBudget, Nat.cast_mul] |
| rw [Real.log_mul hc (mul_ne_zero hp he), Real.log_mul hp he, ← add_assoc] |
|
|
| theorem tendsto_log_rankBudget (Copies : ℕ → Type*) [∀ N, Fintype (Copies N)] |
| (K : ℕ) (hK : 0 < K) |
| (hcopies : ∀ N, 0 < Fintype.card (Copies N)) |
| (hcopyRate : Tendsto (fun N : ℕ => |
| Real.log (Fintype.card (Copies N) : ℝ) / (N : ℝ)) atTop (𝓝 0)) : |
| Tendsto (fun N : ℕ => |
| Real.log (rankBudget (Copies N) K N : ℝ) / ((K : ℝ) * N)) |
| atTop (𝓝 (8 * Real.log 7)) := by |
| have hc : Tendsto (fun N : ℕ => |
| Real.log (Fintype.card (Copies N) : ℝ) / ((K : ℝ) * N)) atTop (𝓝 0) := by |
| have h : Tendsto (fun N : ℕ => |
| (Real.log (Fintype.card (Copies N) : ℝ) / (N : ℝ)) / (K : ℝ)) |
| atTop (𝓝 0) := by |
| simpa only [zero_div] using hcopyRate.div_const (K : ℝ) |
| apply h.congr |
| intro N |
| ring |
| have hsum := (hc.add (tendsto_log_polynomial_overhead K hK)).add |
| (tendsto_log_exponential_source K hK) |
| simp only [zero_add] at hsum |
| apply hsum.congr |
| intro N |
| rw [log_rankBudget (Copies N) K N (hcopies N), add_div, add_div] |
|
|
| end MatrixMultiplication.AllFieldSourceRates |
|
|
| namespace MatrixMultiplication.AllFieldConstructionRates |
|
|
| open MatrixMultiplication.Foundation AllFieldHistory Filter |
| open scoped BigOperators Topology Classical |
|
|
| variable {K : ℕ} |
|
|
| abbrev Copies (allocation : Allocation) (ε : ℝ) (m : ℕ) := |
| ∀ tick : Fin (K + 2), InverseLinearRecovery.MaskRectangles |
| (AllFieldHistoryRecovery.shiftCount (K := K) (tick := tick.val) allocation ε m) |
|
|
| theorem card_copies (allocation : Allocation) (ε : ℝ) (m : ℕ) : |
| Fintype.card (Copies (K := K) allocation ε m) = |
| ∏ tick : Fin (K + 2), RecoveryGrowth.replicationCount |
| (AllFieldHistorySupport.supportRate (K := K) (tick := tick.val) allocation) |
| (AllFieldHistoryMasks.lossConstant (K := K) (tick := tick.val) allocation ε + 6) m := by |
| rw [Fintype.card_pi] |
| apply Finset.prod_congr rfl |
| intro tick _ |
| rw [Fintype.card_eq_nat_card, AllFieldHistoryRecovery.shiftCount] |
| simpa only [Fintype.card_eq_nat_card] using |
| InverseLinearRecovery.card_recovery_copies |
| (AllFieldHistorySupport.supportRate (K := K) (tick := tick.val) allocation) |
| (AllFieldHistoryMasks.lossConstant (K := K) (tick := tick.val) allocation ε + 6) m |
|
|
| theorem card_copies_range (allocation : Allocation) (ε : ℝ) (m : ℕ) : |
| Fintype.card (Copies (K := K) allocation ε m) = |
| ∏ tick ∈ Finset.range (K + 2), Fintype.card |
| (InverseLinearRecovery.MaskRectangles |
| (AllFieldHistoryRecovery.shiftCount (K := K) (tick := tick) allocation ε m)) := by |
| rw [Fintype.card_pi] |
| exact Fin.prod_univ_eq_prod_range (fun tick : ℕ => Fintype.card |
| (InverseLinearRecovery.MaskRectangles |
| (AllFieldHistoryRecovery.shiftCount (K := K) (tick := tick) allocation ε m))) (K + 2) |
|
|
| theorem card_copies_pos (allocation : Allocation) (ε : ℝ) (m : ℕ) : |
| 0 < Fintype.card (Copies (K := K) allocation ε m) := Fintype.card_pos |
|
|
| theorem copies_subexponential (allocation : Allocation) (ε : ℝ) : |
| Tendsto (fun m : ℕ => Real.log (Fintype.card (Copies (K := K) allocation ε m) : ℝ) / |
| (m : ℝ)) atTop (𝓝 0) := by |
| have h := RecoveryGrowth.tendsto_log_prod_div_nat (Finset.univ : Finset (Fin (K + 2))) |
| (r := fun tick m => Fintype.card (InverseLinearRecovery.MaskRectangles |
| (AllFieldHistoryRecovery.shiftCount (K := K) (tick := tick.val) allocation ε m))) |
| (fun _ _ _ => Fintype.card_pos) |
| (fun tick _ => AllFieldHistoryRecovery.replication_subexponential |
| (K := K) (tick := tick.val) allocation ε) |
| simpa only [Copies, Fintype.card_pi] using h |
|
|
| theorem copies_rate (_hK : 0 < K) (allocation : Allocation) (ε : ℝ) : |
| Tendsto (fun m : ℕ => Real.log (Fintype.card (Copies (K := K) allocation ε m) : ℝ) / |
| ((K : ℝ) * populationLength (K := K) allocation m)) atTop (𝓝 0) := by |
| have h := (copies_subexponential (K := K) allocation ε).div_const |
| ((K : ℝ) * denominator (K := K) allocation) |
| simp only [zero_div] at h |
| apply h.congr |
| intro m |
| rw [population_length, Nat.cast_mul] |
| ring |
|
|
| theorem source_rank_rate (hK : 0 < K) (allocation : Allocation) (ε : ℝ) : |
| Tendsto (fun m : ℕ => Real.log |
| (AllFieldSource.rankBudget (Copies (K := K) allocation ε m) K |
| (populationLength (K := K) allocation m) : ℝ) / |
| ((K : ℝ) * populationLength (K := K) allocation m)) |
| atTop (𝓝 (8 * Real.log 7)) := by |
| have hp := (AllFieldSourceRates.tendsto_log_polynomial_overhead K hK).comp |
| (populationLength_tendsto (K := K) allocation) |
| have he := (AllFieldSourceRates.tendsto_log_exponential_source K hK).comp |
| (populationLength_tendsto (K := K) allocation) |
| have h := ((copies_rate hK allocation ε).add hp).add he |
| simp only [zero_add] at h |
| apply h.congr |
| intro m |
| rw [AllFieldSourceRates.log_rankBudget _ _ _ (card_copies_pos allocation ε m), |
| add_div, add_div] |
| rfl |
|
|
| theorem source_rank_terminal_rate (hK : 0 < K) (allocation : Allocation) (ε : ℝ) : |
| Tendsto (fun m : ℕ => Real.log |
| (AllFieldSource.rankBudget |
| (Copies (K := K) allocation ε (AllFieldTerminalRates.terminalDilation K m)) K |
| (AllFieldTerminalRates.terminalLength allocation K m) : ℝ) / |
| ((K : ℝ) * AllFieldTerminalRates.terminalLength allocation K m)) |
| atTop (𝓝 (8 * Real.log 7)) := |
| (source_rank_rate hK allocation ε).comp (terminalDilation_tendsto K) |
|
|
| theorem source_rank_terminal_rate_of_cardinality |
| (ActualCopies : ℕ → Type*) [∀ m, Fintype (ActualCopies m)] |
| (hK : 0 < K) (allocation : Allocation) (ε : ℝ) |
| (cards : ∀ᶠ m : ℕ in atTop, Fintype.card (ActualCopies m) = Fintype.card |
| (Copies (K := K) allocation ε (AllFieldTerminalRates.terminalDilation K m))) : |
| Tendsto (fun m : ℕ => Real.log (AllFieldSource.rankBudget (ActualCopies m) K |
| (AllFieldTerminalRates.terminalLength allocation K m) : ℝ) / |
| ((K : ℝ) * AllFieldTerminalRates.terminalLength allocation K m)) |
| atTop (𝓝 (8 * Real.log 7)) := by |
| apply (source_rank_terminal_rate hK allocation ε).congr' |
| filter_upwards [cards] with m hm |
| simp only [AllFieldSource.rankBudget, hm] |
|
|
| end MatrixMultiplication.AllFieldConstructionRates |
|
|
| end |
|
|
| end MatrixAllFields |
|
|
| end OAI |
|
|
