openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /FieldGroups /AmbientDegree.lean
| import OAI.LinearAlgebra.MatrixMultiplication.FieldConstruction.StageCGibbs | |
| import OAI.LinearAlgebra.MatrixMultiplication.FieldGroups.TargetRate | |
| import OAI.LinearAlgebra.MatrixMultiplication.FieldConstruction.ActiveCapacity | |
| import OAI.LinearAlgebra.MatrixMultiplication.JointExtraction.AmbientEntropy | |
| import OAI.LinearAlgebra.MatrixMultiplication.JointExtraction.AmbientRateLimit | |
| namespace OAI | |
| /-! Group assignments, orbit counts and extraction capacities. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.AllFieldGroupAmbientDegree | |
| open MatrixMultiplication.Foundation AllFieldParameters AllFieldHistory AllFieldActiveLaws | |
| open AllFieldActiveCapacity AllFieldGroupTargetRate JointPopulation JointAmbientDegree | |
| open JointAmbientEntropy JointGibbsApproximation Filter | |
| open scoped BigOperators Topology | |
| attribute [local instance] Classical.propDecidable Classical.decEq | |
| def potential {K : ℕ} (w : PlacedWork K) (s : Fin 3) (k : Fin 17) : ℝ := | |
| match w.1 with | |
| | .stageA h => AllFieldActiveGibbs.physicalPotential positiveInitial tableP | |
| (initialShape h.val) w.2 s k | |
| | .stageB h => AllFieldActiveGibbs.physicalPotential positiveSecond tablep | |
| (aShape h.val) w.2 s k | |
| | .stageC h => AllFieldStageCGibbs.physicalPotential h w.2 s k | |
| def logNormalizer {K : ℕ} (w : PlacedWork K) : ℝ := | |
| match w.1 with | |
| | .stageA h => AllFieldActiveGibbs.splitLogNormalizer positiveInitial tableP | |
| (initialShape h.val) | |
| | .stageB h => AllFieldActiveGibbs.splitLogNormalizer positiveSecond tablep | |
| (aShape h.val) | |
| | .stageC _ => 0 | |
| theorem placedLaw_log {K : ℕ} (w : PlacedWork K) (a : JointPopulation.Shape) | |
| (ha : 0 < (placedLaw w).mass a) : | |
| Real.log ((placedLaw w).mass a) = potential w 0 (shapeSide 0 a) + | |
| potential w 1 (shapeSide 1 a) + potential w 2 (shapeSide 2 a) - | |
| logNormalizer w := by | |
| rcases w with ⟨w, phi⟩ | |
| cases w with | |
| | stageA h => exact AllFieldActiveGibbs.placedLaw_stageA_log h phi a ha | |
| | stageB h => exact AllFieldActiveGibbs.placedLaw_stageB_log h phi a ha | |
| | stageC h => exact AllFieldStageCGibbs.placedLaw_stageC_log h phi a ha | |
| theorem localAllowed_positive {H : Type*} [Fintype H] [DecidableEq H] | |
| (counts : H → JointPopulation.Shape → ℕ) (total : H → ℕ) (h : H) | |
| (word : Positions counts h → JointPopulation.Shape) | |
| (hw : localAllowed counts total h word) {K : ℕ} (w : PlacedWork K) | |
| (htotal : total h = 2 * w.1.halfLength) | |
| (hcounts : ∀ a, 0 < counts h a → 0 < (placedLaw w).mass a) : | |
| ∀ i, 0 < (placedLaw w).mass (word i) := by | |
| have hb := fun a ha => | |
| AllFieldStageCGibbs.placedLaw_positive_parent_bounds w a (hcounts a ha) | |
| rcases w with ⟨w, phi⟩ | |
| cases w with | |
| | stageA a => | |
| apply JointMarginalSupport.localAllowed_positive_reference counts total h word hw | |
| (physicalShape phi (initialShape a.val)) _ hb | |
| intro u hu hle | |
| exact AllFieldActiveGibbs.placedLaw_stageA_positive a phi u | |
| (hu.trans htotal) hle | |
| | stageB a => | |
| apply JointMarginalSupport.localAllowed_positive_reference counts total h word hw | |
| (physicalShape phi (aShape a.val)) _ hb | |
| intro u hu hle | |
| exact AllFieldActiveGibbs.placedLaw_stageB_positive a phi u | |
| (hu.trans htotal) hle | |
| | stageC a => | |
| exact AllFieldStageCGibbs.localAllowed_positive_reference counts total h word hw | |
| a phi htotal hcounts | |
| variable {K tick : ℕ} {sigma : Placement} | |
| def orderTotal (h : ActiveOrder K tick sigma) : ℕ := 2 * h.val.val.1.halfLength | |
| theorem canonicalLaw_mass_eq (allocation : Allocation) (m : ℕ) | |
| (h : ActiveOrder K tick sigma) | |
| (hpos : 0 < Fintype.card (Positions (orderCounts allocation m) h)) : | |
| (canonicalLaw (orderCounts allocation m) h).mass = (orderLaw h).mass := by | |
| have hcard : Fintype.card (Positions (orderCounts allocation m) h) = | |
| population allocation m (h.val.val.1.source, h.val.val.2) := by | |
| simpa only [Positions, Fintype.card_fin] using orderCounts_sum allocation m h | |
| funext a | |
| rw [canonicalLaw_mass_of_pos _ h hpos, hcard] | |
| change (jointCounts allocation m h.val.val a : ℝ) / | |
| population allocation m (h.val.val.1.source, h.val.val.2) = _ | |
| rw [jointCounts_cast] | |
| exact mul_div_cancel_left₀ _ (by exact_mod_cast (hcard ▸ hpos).ne') | |
| theorem localAllowed_entropy_le (allocation : Allocation) (m : ℕ) | |
| (h : ActiveOrder K tick sigma) | |
| (word : Positions (orderCounts allocation m) h → JointPopulation.Shape) | |
| (hw : localAllowed (orderCounts allocation m) orderTotal h word) : | |
| finiteEntropy (fun a => (wordPopulation word a : ℝ) / | |
| Fintype.card (Positions (orderCounts allocation m) h)) ≤ | |
| finiteEntropy (orderLaw h).mass := by | |
| by_cases hpos : 0 < Fintype.card (Positions (orderCounts allocation m) h) | |
| · have hs := localAllowed_positive (orderCounts allocation m) orderTotal h word hw | |
| h.val.val rfl (fun a ha => | |
| AllFieldStageCGibbs.jointCounts_positive_reference allocation m h.val.val a ha) | |
| have he := localAllowed_entropy_le_of_word_support (orderCounts allocation m) | |
| orderTotal h word (orderLaw h) (potential h.val.val 0) (potential h.val.val 1) | |
| (potential h.val.val 2) (logNormalizer h.val.val) hs | |
| (placedLaw_log h.val.val) hw | |
| have hc := canonicalLaw_mass_eq allocation m h hpos | |
| simpa only [gibbsCap, marginalError, FiniteLaw.map_mass, hc, sub_self, abs_zero, | |
| zero_mul, Finset.sum_const_zero, add_zero] using he | |
| · have hz := Nat.eq_zero_of_not_pos hpos | |
| simpa only [hz, Nat.cast_zero, div_zero, finiteEntropy, entropyTerm_zero, | |
| Finset.sum_const_zero] using (orderLaw h).entropy_nonneg | |
| theorem tendsto_firstExponent (allocation : Allocation) (sigma : Placement) : | |
| Tendsto (fun m : ℕ => (∑ h : ActiveOrder K tick sigma, | |
| classExponent (orderCounts allocation m) (sigma 0) | |
| (triple (orderCounts allocation m) (canonicalTarget (orderCounts allocation m))) h | |
| (finiteEntropy (orderLaw h).mass)) / (m : ℝ)) atTop | |
| (𝓝 (orderNativeDegree (K := K) (tick := tick) allocation sigma 0)) := by | |
| have hsize (h : ActiveOrder K tick sigma) := | |
| JointPopulationRates.tendsto_total_div_of_coordinate_rates | |
| (fun m => orderCounts allocation m h) | |
| ((populationLength (K := K) allocation 1 : ℝ) * orderMass allocation h) | |
| (orderLaw h).mass (orderLaw h).total (orderCounts_dilation_rate allocation h) | |
| have hside (h : ActiveOrder K tick sigma) := | |
| JointPopulationRates.tendsto_weighted_target_side_entropy | |
| (fun m => orderCounts allocation m) | |
| (fun m => canonicalTarget (orderCounts allocation m)) | |
| (fun h => (populationLength (K := K) allocation 1 : ℝ) * orderMass allocation h) | |
| (fun h => (orderLaw h).mass) (fun h => (orderLaw h).total) | |
| (orderCounts_dilation_rate allocation) h (sigma 0) | |
| have hr := JointAmbientRateLimit.tendsto_sum_classExponent_div_nat | |
| (fun m => orderCounts allocation m) (sigma 0) | |
| (fun _ h => finiteEntropy (orderLaw h).mass) | |
| (fun h => (populationLength (K := K) allocation 1 : ℝ) * orderMass allocation h) | |
| (fun h => ((populationLength (K := K) allocation 1 : ℝ) * orderMass allocation h) * | |
| finiteEntropy (orderLaw h).mass) | |
| (fun h => ((populationLength (K := K) allocation 1 : ℝ) * orderMass allocation h) * | |
| finiteEntropy (JointPopulationRates.sideMass (orderLaw h).mass (sigma 0))) | |
| hsize (fun h => (hsize h).mul_const (finiteEntropy (orderLaw h).mass)) | |
| (fun h => by simpa only [Positions, Fintype.card_fin] using hside h) | |
| simpa only [orderNativeDegree, order_first_capacity, mul_sub] using hr | |
| theorem eventually_sharedAmbient_first_card_le (allocation : Allocation) | |
| (sigma : Placement) {ε : ℝ} (hε : 0 < ε) : | |
| ∀ᶠ m in atTop, ∀ e : Target | |
| (orderCounts (K := K) (tick := tick) (sigma := sigma) allocation m), | |
| ((sharedAmbient (orderCounts allocation m) orderTotal (sigma 0) | |
| (triple (orderCounts allocation m) e)).card : ℝ) ≤ | |
| Real.exp ((m : ℝ) * | |
| (orderNativeDegree (K := K) (tick := tick) allocation sigma 0 + ε)) := by | |
| filter_upwards [(tendsto_order.1 | |
| (tendsto_firstExponent (K := K) (tick := tick) allocation sigma)).2 | |
| (orderNativeDegree (K := K) (tick := tick) allocation sigma 0 + ε) | |
| (lt_add_of_pos_right _ hε), eventually_gt_atTop (0 : ℕ)] with m hm hmp | |
| intro e | |
| have hmr : (0 : ℝ) < m := by exact_mod_cast hmp | |
| have hb := sharedAmbient_card_le (orderCounts allocation m) orderTotal (sigma 0) | |
| (triple (orderCounts allocation m) e) (fun h => finiteEntropy (orderLaw h).mass) | |
| (fun h word hw => localAllowed_entropy_le allocation m h word hw) | |
| apply hb.trans | |
| simp_rw [classBound_eq_exp] | |
| rw [← Real.exp_sum] | |
| apply Real.exp_le_exp.mpr | |
| simp_rw [classExponent_target_eq] | |
| simpa only [mul_comm] using (div_le_iff₀ hmr).mp hm.le | |
| end MatrixMultiplication.AllFieldGroupAmbientDegree | |
| end | |
| end OAI | |