| import Mathlib |
| import OAI.LinearAlgebra.MatrixFields.Histories.HistorySums |
| import OAI.LinearAlgebra.MatrixFields.Tensors.CWWordDimensionParameters |
|
|
| namespace OAI |
|
|
| namespace MatrixAllFields |
|
|
| open scoped BigOperators Topology Polynomial |
|
|
| namespace MatrixMultiplication.AllFieldParameters |
|
|
| open MatrixMultiplication.Foundation |
| open scoped BigOperators |
|
|
| noncomputable section |
|
|
| theorem entropy_two_points {A : Type*} [Fintype A] [DecidableEq A] |
| (a b : A) (hab : a ≠ b) (p q : ℝ) : |
| finiteEntropy (fun i => if i = a then p else if i = b then q else 0) = |
| entropyTerm p + entropyTerm q := by |
| unfold finiteEntropy |
| calc |
| _ = ∑ i : A, ((if i = a then entropyTerm p else 0) + |
| (if i = b then entropyTerm q else 0)) := by |
| apply Finset.sum_congr rfl |
| intro i _ |
| by_cases hi : i = a |
| · subst i |
| simp [hab] |
| · by_cases hj : i = b |
| · subst i |
| simp [hab.symm] |
| · simp [hi, hj] |
| _ = _ := by simp [Finset.sum_add_distrib] |
|
|
| theorem weighted_two_points {A : Type*} [Fintype A] [DecidableEq A] |
| (a b : A) (hab : a ≠ b) (p q : ℝ) (f : A → ℝ) : |
| (∑ i : A, (if i = a then p else if i = b then q else 0) * f i) = |
| p * f a + q * f b := by |
| calc |
| _ = ∑ i : A, ((if i = a then p * f a else 0) + |
| (if i = b then q * f b else 0)) := by |
| apply Finset.sum_congr rfl |
| intro i _ |
| by_cases hi : i = a |
| · subst i |
| simp [hab] |
| · by_cases hj : i = b |
| · subst i |
| simp [hi] |
| · simp [hi, hj] |
| _ = _ := by simp [Finset.sum_add_distrib] |
|
|
| def statisticRate (d : ℚ) (k : Fin 5) : ℝ := |
| finiteEntropy (fun i : Fin 6 => (statisticLaw d k i : ℝ)) + |
| ∑ i : Fin 6, (statisticLaw d k i : ℝ) * Real.log (multiplicity i : ℝ) |
|
|
| def binaryEntropyRate (d : ℚ) : ℝ := |
| entropyTerm (1 - (d : ℝ)) + entropyTerm (d : ℝ) + (d : ℝ) * Real.log 2 |
|
|
| theorem statisticLaw_two_real (d : ℚ) (i : Fin 6) : |
| (statisticLaw d 2 i : ℝ) = |
| if i = 2 then 1 - (d : ℝ) else if i = 3 then (d : ℝ) else 0 := by |
| by_cases hi : i = 2 |
| · simp [statisticLaw, hi] |
| · by_cases hj : i = 3 <;> simp [statisticLaw, hi, hj] |
|
|
| theorem statisticRate_two (d : ℚ) : |
| statisticRate d 2 = binaryEntropyRate d + 2 * (1 - (d : ℝ)) * Real.log 5 := by |
| unfold statisticRate |
| simp_rw [statisticLaw_two_real] |
| rw [entropy_two_points (2 : Fin 6) 3 (by decide), |
| weighted_two_points (2 : Fin 6) 3 (by decide)] |
| have h25 : Real.log (25 : ℝ) = 2 * Real.log 5 := by |
| have hp : (5 : ℝ) ^ 2 = 25 := by norm_num |
| rw [← hp, Real.log_pow] |
| norm_num |
| change entropyTerm (1 - (d : ℝ)) + entropyTerm (d : ℝ) + |
| ((1 - (d : ℝ)) * Real.log 25 + (d : ℝ) * Real.log 2) = _ |
| rw [h25] |
| unfold binaryEntropyRate |
| ring |
|
|
| theorem statisticRate_deterministic (d : ℚ) (k : Fin 5) (hk : k.val ≠ 2) : |
| statisticRate d k = Real.log (multiplicity (singletonSlot k.val) : ℝ) := by |
| have hmass (i : Fin 6) : (statisticLaw d k i : ℝ) = |
| if i = singletonSlot k.val then 1 else 0 := by |
| by_cases hi : i = singletonSlot k.val <;> simp [statisticLaw, hk, hi] |
| unfold statisticRate finiteEntropy |
| simp_rw [hmass] |
| simp [entropyTerm, apply_ite] |
|
|
| theorem statisticRate_zero (d : ℚ) : statisticRate d 0 = 0 := by |
| rw [statisticRate_deterministic d 0 (by decide)] |
| norm_num [singletonSlot, multiplicity] |
|
|
| theorem statisticRate_one (d : ℚ) : statisticRate d 1 = Real.log 10 := by |
| rw [statisticRate_deterministic d 1 (by decide)] |
| norm_num [singletonSlot, multiplicity] |
|
|
| theorem statisticRate_three (d : ℚ) : statisticRate d 3 = Real.log 10 := by |
| rw [statisticRate_deterministic d 3 (by decide)] |
| change Real.log (10 : ℝ) = Real.log 10 |
| rfl |
|
|
| theorem statisticRate_four (d : ℚ) : statisticRate d 4 = 0 := by |
| rw [statisticRate_deterministic d 4 (by decide)] |
| have hv : multiplicity (singletonSlot (4 : Fin 5).val) = 1 := by decide +kernel |
| rw [hv] |
| norm_num |
|
|
| end |
|
|
| end MatrixMultiplication.AllFieldParameters |
|
|
| noncomputable section |
|
|
| namespace MatrixMultiplication.AllFieldTerminalRates |
|
|
| open AllFieldParameters AllFieldHistory |
| open scoped BigOperators |
| attribute [local instance] Classical.propDecidable Classical.decEq |
|
|
| def initialRate (g : Shape) : ℝ := |
| Real.log (Contractions.coefficients[shapeMax g]?.getD 0 : ℝ) |
|
|
| def S0 : ℝ := |
| ((sortedInitial.filter (fun g => !positive g)).map |
| (fun g => (initialLaw g : ℝ) * initialRate g)).sum |
|
|
| def S1 : ℝ := |
| (zeroSecond.map (fun t => (secondMass t : ℝ) * AllFieldZeroLeafRates.fourRate t)).sum |
|
|
| def secondLeafRate (t u : Shape) : ℝ := |
| if shapeMax u = 4 then 0 |
| else if shapeMax u = 3 then Real.log 10 |
| else if !positive u then |
| binaryEntropyRate (binaryParameter t u) + |
| 2 * (1 - (binaryParameter t u : ℝ)) * Real.log 5 |
| else (2 - (binaryParameter t u : ℝ)) * Real.log 5 |
|
|
| def S2 : ℝ := |
| (positiveSecond.map (fun t => |
| ((below t).map (fun u => (littleMass t u : ℝ) * secondLeafRate t u)).sum)).sum |
|
|
| def S : ℝ := (S0 + S1) + S2 |
|
|
| private theorem four_shape_max_lt_five : ∀ u ∈ shapes 4, shapeMax u < 5 := by |
| decide +kernel |
|
|
| private theorem four_zero_max : ∀ u ∈ shapes 4, positive u = false → |
| shapeMax u = 2 ∨ shapeMax u = 3 ∨ shapeMax u = 4 := by |
| decide +kernel |
|
|
| private theorem four_positive_max : ∀ u ∈ shapes 4, positive u = true → |
| shapeMax u = 2 := by |
| decide +kernel |
|
|
| theorem second_shapeMax_lt_five (t : Shape) (ht : t ∈ positiveSecond) |
| (u : Shape) (hu : u ∈ below t) : shapeMax u < 5 := |
| four_shape_max_lt_five u (stageB_children_size t ht u hu) |
|
|
| theorem secondLeafRate_zero (t : Shape) (ht : t ∈ positiveSecond) |
| (u : Shape) (hu : u ∈ below t) (hz : positive u = false) : |
| secondLeafRate t u = statisticRate (binaryParameter t u) |
| ⟨shapeMax u, second_shapeMax_lt_five t ht u hu⟩ := by |
| rcases four_zero_max u (stageB_children_size t ht u hu) hz with h2 | h3 | h4 |
| · have hk : (⟨shapeMax u, second_shapeMax_lt_five t ht u hu⟩ : Fin 5) = 2 := |
| Fin.ext h2 |
| rw [hk, statisticRate_two] |
| simp [secondLeafRate, h2, hz] |
| · have hk : (⟨shapeMax u, second_shapeMax_lt_five t ht u hu⟩ : Fin 5) = 3 := |
| Fin.ext h3 |
| rw [hk, statisticRate_three] |
| simp [secondLeafRate, h3] |
| · have hk : (⟨shapeMax u, second_shapeMax_lt_five t ht u hu⟩ : Fin 5) = 4 := |
| Fin.ext h4 |
| rw [hk, statisticRate_four] |
| simp [secondLeafRate, h4] |
|
|
| theorem secondLeafRate_positive (t : Shape) (ht : t ∈ positiveSecond) |
| (u : Shape) (hu : u ∈ below t) (hp : positive u = true) : |
| secondLeafRate t u = (2 - (binaryParameter t u : ℝ)) * Real.log 5 := by |
| have hm := four_positive_max u (stageB_children_size t ht u hu) hp |
| simp [secondLeafRate, hm, hp] |
|
|
| theorem secondLeafRate_builder_expression (t u : Shape) : |
| secondLeafRate t u = |
| if shapeMax u = 4 then 0 |
| else if shapeMax u = 3 then Real.log 10 |
| else if !positive u then |
| (MatrixMultiplication.Foundation.entropyTerm (1 - (binaryParameter t u : ℝ)) + |
| MatrixMultiplication.Foundation.entropyTerm (binaryParameter t u : ℝ) + |
| (binaryParameter t u : ℝ) * Real.log 2) + |
| ((1 - (binaryParameter t u : ℝ)) * 2) * Real.log 5 |
| else (2 - (binaryParameter t u : ℝ)) * Real.log 5 := by |
| unfold secondLeafRate |
| split_ifs <;> try rfl |
| unfold binaryEntropyRate |
| ring |
|
|
| private theorem list_filter_sum_inline_MatrixMultiplication_AllFieldTerminalRateFormulas {A : Type*} (xs : List A) (p : A → Bool) |
| (f : A → ℝ) : |
| ((xs.filter p).map f).sum = (xs.map (fun a => if p a then f a else 0)).sum := by |
| induction xs with |
| | nil => simp |
| | cons a xs ih => cases hp : p a <;> simp [hp, ih] |
|
|
| theorem initial_zero_history_rate (K : ℕ) : |
| (∑ h : {h : Initial K // initialShape h ∉ positiveInitial}, |
| (initialAmount h.val : ℝ) * initialRate (initialShape h.val)) = (K : ℝ) * S0 := by |
| calc |
| _ = ∑ h : Initial K, if initialShape h ∉ positiveInitial then |
| (initialAmount h : ℝ) * initialRate (initialShape h) else 0 := by |
| rw [← Finset.sum_filter] |
| exact (Finset.sum_subtype |
| (p := fun h : Initial K => initialShape h ∉ positiveInitial) |
| (Finset.univ.filter (fun h : Initial K => initialShape h ∉ positiveInitial)) |
| (by simp) |
| (fun h : Initial K => (initialAmount h : ℝ) * initialRate (initialShape h))).symm |
| _ = ∑ h : Initial K, (initialAmount h : ℝ) * |
| (if initialShape h ∉ positiveInitial then initialRate (initialShape h) else 0) := by |
| apply Finset.sum_congr rfl |
| intro h _ |
| split_ifs <;> simp |
| _ = _ := by |
| rw [initial_history_sum K |
| (fun g => if g ∉ positiveInitial then initialRate g else 0), S0, list_filter_sum_inline_MatrixMultiplication_AllFieldTerminalRateFormulas] |
| apply congrArg (fun x : ℝ => (K : ℝ) * x) |
| apply congrArg List.sum |
| apply List.map_congr_left |
| intro g hg |
| cases hp : positive g <;> simp [positiveInitial, hg, hp] |
|
|
| end MatrixMultiplication.AllFieldTerminalRates |
|
|
| namespace MatrixMultiplication.AllFieldInitialLeafRates |
|
|
| open AllFieldHistory AllFieldParameters AllFieldTerminalRates |
| open CWWindowedLeaves Filter |
| open scoped BigOperators Topology |
| attribute [local instance] Classical.propDecidable Classical.decEq |
|
|
| abbrev InitialZero (K : ℕ) := |
| {h : Initial K // initialShape h ∉ positiveInitial} |
|
|
| abbrev PopulationHistory (K : ℕ) := InitialZero K × Placement |
|
|
| theorem shapeMax_lt {K : ℕ} (h : InitialZero K) : |
| shapeMax (initialShape h.val) < 17 := by |
| have hb := (root_shape_spec _ (initialShape_mem h.val)).1 |
| exact Nat.lt_succ_of_le (max_le (hb 0) (max_le (hb 1) (hb 2))) |
|
|
| def shapeIndex {K : ℕ} (h : InitialZero K) : Fin 17 := |
| ⟨shapeMax (initialShape h.val), shapeMax_lt h⟩ |
|
|
| theorem card_alphabet {K : ℕ} (h : InitialZero K) : |
| Fintype.card (Alphabet 8 (shapeMax (initialShape h.val))) = |
| Contractions.coefficients[shapeMax (initialShape h.val)]?.getD 0 := by |
| have hc := CWWordDimensionParameters.table_eq_card (shapeIndex h) |
| rw [Fintype.card_eq_nat_card] at hc ⊢ |
| exact hc.symm |
|
|
| theorem card_alphabet_pos {K : ℕ} (h : InitialZero K) : |
| 0 < Fintype.card (Alphabet 8 (shapeMax (initialShape h.val))) := by |
| have hc := CWWordDimensionParameters.word_card_positive (shapeIndex h) |
| rw [Fintype.card_eq_nat_card] at hc ⊢ |
| exact hc |
|
|
| abbrev Words {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (h : PopulationHistory K) := |
| Fin (population allocation dilation (.initial h.1.val, h.2)) → |
| Alphabet 8 (shapeMax (initialShape h.1.val)) |
|
|
| theorem card_words {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (h : PopulationHistory K) : |
| Fintype.card (Words allocation dilation h) = |
| (Contractions.coefficients[shapeMax (initialShape h.1.val)]?.getD 0) ^ |
| population allocation dilation (.initial h.1.val, h.2) := by |
| simp only [Words, Fintype.card_fun, Fintype.card_fin, card_alphabet] |
|
|
| theorem card_words_pos {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (h : PopulationHistory K) : |
| 0 < Fintype.card (Words allocation dilation h) := by |
| simp only [Words, Fintype.card_fun, Fintype.card_fin] |
| exact pow_pos (card_alphabet_pos h.1) _ |
|
|
| theorem log_card_words {K : ℕ} (allocation : Allocation) (dilation : ℕ) |
| (h : PopulationHistory K) : |
| Real.log (Fintype.card (Words allocation dilation h) : ℝ) = |
| (population allocation dilation (.initial h.1.val, h.2) : ℝ) * |
| initialRate (initialShape h.1.val) := by |
| simp only [card_words, Nat.cast_pow, Real.log_pow, initialRate] |
|
|
| abbrev ProductWords {K : ℕ} (allocation : Allocation) (dilation : ℕ) := |
| ∀ h : PopulationHistory K, Words allocation dilation h |
|
|
| def volume {K : ℕ} (allocation : Allocation) (dilation : ℕ) : ℕ := |
| Fintype.card (ProductWords (K := K) allocation dilation) |
|
|
| theorem volume_eq_prod {K : ℕ} (allocation : Allocation) (dilation : ℕ) : |
| volume (K := K) allocation dilation = |
| ∏ h : PopulationHistory K, Fintype.card (Words allocation dilation h) := by |
| rw [volume, Fintype.card_pi] |
|
|
| theorem volume_pos {K : ℕ} (allocation : Allocation) (dilation : ℕ) : |
| 0 < volume (K := K) allocation dilation := by |
| rw [volume_eq_prod] |
| exact Finset.prod_pos (fun h _ => card_words_pos allocation dilation h) |
|
|
| theorem log_volume {K : ℕ} (allocation : Allocation) (dilation : ℕ) : |
| Real.log (volume (K := K) allocation dilation : ℝ) = |
| (populationLength (K := K) allocation dilation : ℝ) * |
| ∑ h : PopulationHistory K, |
| (amount allocation (.initial h.1.val, h.2) : ℝ) * |
| initialRate (initialShape h.1.val) := by |
| rw [volume_eq_prod, Nat.cast_prod, Real.log_prod |
| (fun h _ => Nat.cast_ne_zero.mpr |
| (Nat.ne_of_gt (card_words_pos allocation dilation h)))] |
| simp only [log_card_words] |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro h _ |
| have hc : (population allocation dilation (.initial h.1.val, h.2) : ℝ) = |
| (populationLength (K := K) allocation dilation : ℝ) * |
| (amount allocation (.initial h.1.val, h.2) : ℝ) := by |
| exact_mod_cast population_cast allocation dilation (.initial h.1.val, h.2) |
| rw [hc, mul_assoc] |
|
|
| theorem sum_populationHistory_rate {K : ℕ} (allocation : Allocation) : |
| (∑ h : PopulationHistory K, |
| (amount allocation (.initial h.1.val, h.2) : ℝ) * |
| initialRate (initialShape h.1.val)) = |
| ∑ h : InitialZero K, |
| (initialAmount h.val : ℝ) * initialRate (initialShape h.val) := by |
| rw [Fintype.sum_prod_type] |
| apply Finset.sum_congr rfl |
| intro h _ |
| dsimp only |
| rw [← Finset.sum_mul] |
| have hm : (∑ phi : Placement, (amount allocation (.initial h.val, phi) : ℝ)) = |
| (initialAmount h.val : ℝ) := by |
| exact_mod_cast sum_placement_amount allocation (.initial h.val) |
| rw [hm] |
|
|
| theorem log_volume_eq_S0 {K : ℕ} (allocation : Allocation) (dilation : ℕ) : |
| Real.log (volume (K := K) allocation dilation : ℝ) = |
| (populationLength (K := K) allocation dilation : ℝ) * ((K : ℝ) * S0) := by |
| rw [log_volume, sum_populationHistory_rate, initial_zero_history_rate] |
|
|
| theorem normalized_log_volume_eq_S0 {K : ℕ} (allocation : Allocation) |
| (dilation : ℕ) (hd : 0 < dilation) : |
| Real.log (volume (K := K) allocation dilation : ℝ) / |
| populationLength (K := K) allocation dilation = (K : ℝ) * S0 := by |
| rw [log_volume_eq_S0] |
| have hn : (populationLength (K := K) allocation dilation : ℝ) ≠ 0 := |
| Nat.cast_ne_zero.mpr |
| (Nat.ne_of_gt (AllFieldPopulationCounts.blockLength_pos _ hd)) |
| exact mul_div_cancel_left₀ _ hn |
|
|
| theorem tendsto_normalized_log_volume {K : ℕ} (allocation : Allocation) : |
| Tendsto (fun dilation : ℕ => |
| Real.log (volume (K := K) allocation dilation : ℝ) / |
| populationLength (K := K) allocation dilation) atTop (𝓝 ((K : ℝ) * S0)) := by |
| apply tendsto_const_nhds.congr' |
| filter_upwards [eventually_gt_atTop (0 : ℕ)] with dilation hd |
| exact (normalized_log_volume_eq_S0 allocation dilation hd).symm |
|
|
| end MatrixMultiplication.AllFieldInitialLeafRates |
|
|
| end |
|
|
| end MatrixAllFields |
|
|
| end OAI |
|
|
