| import OAI.NumberTheory.DukePrimeDegree.Geometry.RemainingIntrinsicProduct |
| import OAI.NumberTheory.DukePrimeDegree.Entropy.RootProductInformation |
|
|
| namespace OAI |
|
|
| /-! # Finite diagonal orbit tubes in a remaining root group |
|
|
| These are actual conjugation tubes, not assumed entropy partitions. |
| Their information is computed exactly; the passage from these tubes to |
| metric entropy is a separate step. |
| -/ |
|
|
| noncomputable section |
| open Matrix MeasureTheory Set Filter |
| open scoped ENNReal BigOperators Topology |
| namespace DukePrimeDegree |
| open PrimeDegreePackets |
|
|
| lemma exp_scaled_abs_lt_iff (a ρ x : ℝ) : |
| |Real.exp a * x| < Real.exp (-ρ) ↔ |x| < Real.exp (-(ρ+a)) := by |
| rw [abs_mul, abs_of_pos (Real.exp_pos a), mul_comm (Real.exp a), |
| ←lt_div_iff₀ (Real.exp_pos a), ←Real.exp_sub, |
| show -ρ-a = -(ρ+a) by ring] |
|
|
| lemma finite_exp_scaled_abs_lt_iff (a ρ x : ℝ) (N : ℕ) : |
| (∀ k : ℕ, k ≤ N → |Real.exp (a*k) * x| < Real.exp (-ρ)) ↔ |
| |x| < Real.exp (-(ρ+(N:ℝ)*max a 0)) := by |
| simp_rw [exp_scaled_abs_lt_iff] |
| by_cases ha : 0 ≤ a |
| · rw [max_eq_left ha] |
| constructor |
| · intro h |
| simpa only [mul_comm a] using h N le_rfl |
| · intro h k hk |
| apply h.trans_le |
| apply Real.exp_le_exp.mpr |
| have hkn : (k : ℝ) ≤ N := by exact_mod_cast hk |
| nlinarith |
| · rw [max_eq_right (le_of_not_ge ha),mul_zero,add_zero] |
| constructor |
| · intro h |
| simpa only [Nat.cast_zero,mul_zero,add_zero] using h 0 (Nat.zero_le _) |
| · intro h k _ |
| apply h.trans_le |
| apply Real.exp_le_exp.mpr |
| have hak : a*(k:ℝ) ≤ 0 := mul_nonpos_of_nonpos_of_nonneg |
| (le_of_not_ge ha) (Nat.cast_nonneg _) |
| linarith |
|
|
| namespace EliminationChain |
| variable {n : ℕ} {P : Finset (Fin n × Fin n)} {D : Finset (Fin n)} |
|
|
| / |
| remaining matrix entry bounded by `exp (-ρ)` through time `N`. -/ |
| def remainingBackwardTube (_c : EliminationChain P D) |
| (ell : Fin n → ℝ) (hell : ∑ i, ell i = 0) (ρ : ℝ) (N : ℕ) : |
| Set (positiveRootGeneratedGroup (allPositiveRoots n \ P)) := |
| {u | ∀ k : ℕ, k ≤ N → ∀ p : ↥(allPositiveRoots n \ P), |
| |(diagonalOneParameter ell hell k * u.val * |
| diagonalOneParameter ell hell (-k)).val p.val.1 p.val.2| < Real.exp (-ρ)} |
|
|
| theorem remainingBackwardTube_eq_rectangle (c : EliminationChain P D) |
| (hP : InitialRootPattern P) (hf : c.finalEntries = allPositiveRoots n) |
| (ell : Fin n → ℝ) (hell : ∑ i, ell i = 0) (ρ : ℝ) (N : ℕ) : |
| c.remainingBackwardTube ell hell ρ N = |
| (c.remainingGroupCoordinates hP hf).symm '' |
| Set.pi univ (fun p => Metric.ball 0 |
| (Real.exp (-(ρ+(N:ℝ)*max (ell p.val.1-ell p.val.2) 0)))) := by |
| let E := c.remainingGroupCoordinates hP hf |
| ext u |
| constructor |
| · intro hu |
| refine ⟨E u, ?_, E.symm_apply_apply u⟩ |
| intro p _ |
| simp only [Metric.mem_ball,Real.dist_eq,sub_zero] |
| rw [remainingGroupCoordinates_apply] |
| apply (finite_exp_scaled_abs_lt_iff _ _ _ N).mp |
| intro k hk |
| simpa only [conjugation_entry] using hu k hk p |
| · rintro ⟨v,hv,rfl⟩ k hk p |
| rw [conjugation_entry] |
| apply (finite_exp_scaled_abs_lt_iff _ _ _ N).mpr ?_ k hk |
| have hp := hv p (mem_univ p) |
| simp only [Metric.mem_ball,Real.dist_eq,sub_zero] at hp |
| have he : (E.symm v).val.val p.val.1 p.val.2 = v p := by |
| rw [←c.remainingGroupCoordinates_apply hP hf] |
| exact congrFun (E.apply_symm_apply v) p |
| change |(E.symm v).val.val p.val.1 p.val.2| < _ |
| rw [he] |
| exact hp |
|
|
| theorem remainingBackwardTube_measurableSet (c : EliminationChain P D) |
| (hP : InitialRootPattern P) (hf : c.finalEntries = allPositiveRoots n) |
| (ell : Fin n → ℝ) (hell : ∑ i, ell i = 0) (ρ : ℝ) (N : ℕ) : |
| MeasurableSet (c.remainingBackwardTube ell hell ρ N) := by |
| rw [c.remainingBackwardTube_eq_rectangle hP hf] |
| apply (c.remainingGroupCoordinates hP hf).symm.measurableEmbedding.measurableSet_image.mpr |
| exact MeasurableSet.pi Set.countable_univ (fun _ _ => Metric.isOpen_ball.measurableSet) |
|
|
| / |
| intrinsic remaining-subgroup leaf. -/ |
| def remainingBackwardTubeInformation (c : EliminationChain P D) |
| (hP : InitialRootPattern P) (hf : c.finalEntries = allPositiveRoots n) |
| (ell : Fin n → ℝ) (hell : ∑ i, ell i = 0) (ρ : ℝ) (N : ℕ) |
| (μ : Measure (X n)) [IsFiniteMeasure μ] (x : X n) : ℝ := |
| -Real.log ((c.remainingIntrinsicProduct hP hf μ x) |
| (c.remainingBackwardTube ell hell ρ N)).toReal |
|
|
| end EliminationChain |
|
|
| namespace EliminationChain |
| variable {d : ℕ} {P : Finset (Fin (d+1) × Fin (d+1))} {D : Finset (Fin (d+1))} |
|
|
| theorem remainingBackwardTubeInformation_eq (c : EliminationChain P D) |
| (hP : InitialRootPattern P) (hf : c.finalEntries = allPositiveRoots (d+1)) |
| (ell : Fin (d+1) → ℝ) (hell : ∑ i, ell i = 0) (ρ : ℝ) (N : ℕ) |
| (μ : Measure (X (d+1))) [IsProbabilityMeasure μ] (x : X (d+1)) : |
| c.remainingBackwardTubeInformation hP hf ell hell ρ N μ x = |
| rootProductInformation d (fun p : ↥(allPositiveRoots (d+1) \ P) => p.val.1) |
| (fun p => p.val.2) |
| (fun p => ne_of_lt (Finset.mem_filter.mp (Finset.mem_sdiff.mp p.prop).1).2) |
| μ (fun p => ρ+(N:ℝ)*max (ell p.val.1-ell p.val.2) 0) x := by |
| let E := c.remainingGroupCoordinates hP hf |
| rw [remainingBackwardTubeInformation,c.remainingBackwardTube_eq_rectangle hP hf] |
| have hB : MeasurableSet (Set.pi univ (fun p : ↥(allPositiveRoots (d+1) \ P) => |
| Metric.ball (0:ℝ) (Real.exp (-(ρ+(N:ℝ)*max (ell p.val.1-ell p.val.2) 0))))) := |
| MeasurableSet.pi Set.countable_univ (fun _ _ => Metric.isOpen_ball.measurableSet) |
| rw [remainingIntrinsicProduct,Measure.map_apply E.symm.measurable |
| (E.symm.measurableEmbedding.measurableSet_image.mpr hB),E.symm.injective.preimage_image] |
| rfl |
|
|
| theorem integrable_remainingBackwardTubeInformation (c : EliminationChain P D) |
| (hP : InitialRootPattern P) (hf : c.finalEntries = allPositiveRoots (d+1)) |
| (ell : Fin (d+1) → ℝ) (hell : ∑ i, ell i = 0) (ρ : ℝ) (N : ℕ) |
| (μ : Measure (X (d+1))) [IsProbabilityMeasure μ] |
| (hA : ∀ u : LogCoordinates d, μ.map (fun x => rightAction x (diagonalFlow u)) = μ) : |
| Integrable (c.remainingBackwardTubeInformation hP hf ell hell ρ N μ) μ := by |
| have he := funext (c.remainingBackwardTubeInformation_eq hP hf ell hell ρ N μ) |
| rw [he] |
| exact integrable_rootProductInformation d _ _ _ μ hA _ |
|
|
| / |
| depending only on its initial radius. -/ |
| theorem integral_remainingBackwardTubeInformation (c : EliminationChain P D) |
| (hP : InitialRootPattern P) (hf : c.finalEntries = allPositiveRoots (d+1)) |
| (ell : Fin (d+1) → ℝ) (hell : ∑ i, ell i = 0) (ρ : ℝ) (N : ℕ) |
| (μ : Measure (X (d+1))) [IsProbabilityMeasure μ] |
| (hA : ∀ u : LogCoordinates d, μ.map (fun x => rightAction x (diagonalFlow u)) = μ) : |
| (∫ x, c.remainingBackwardTubeInformation hP hf ell hell ρ N μ x ∂μ) = |
| ρ * (∑ p : ↥(allPositiveRoots (d+1) \ P), canonicalRootCoefficient d μ p.val.1 p.val.2) + |
| (N:ℝ) * (∑ p : ↥(allPositiveRoots (d+1) \ P), |
| max (ell p.val.1-ell p.val.2) 0 * canonicalRootCoefficient d μ p.val.1 p.val.2) := by |
| simp_rw [c.remainingBackwardTubeInformation_eq hP hf] |
| rw [integral_rootProductInformation d _ _ _ μ hA] |
| simp only [add_mul,Finset.sum_add_distrib,←Finset.mul_sum,mul_assoc] |
|
|
| / |
| theorem tendsto_mean_remainingBackwardTubeInformation (c : EliminationChain P D) |
| (hP : InitialRootPattern P) (hf : c.finalEntries = allPositiveRoots (d+1)) |
| (ell : Fin (d+1) → ℝ) (hell : ∑ i, ell i = 0) (ρ : ℝ) |
| (μ : Measure (X (d+1))) [IsProbabilityMeasure μ] |
| (hA : ∀ u : LogCoordinates d, μ.map (fun x => rightAction x (diagonalFlow u)) = μ) : |
| Tendsto (fun N : ℕ => |
| (∫ x, c.remainingBackwardTubeInformation hP hf ell hell ρ N μ x ∂μ) / (N:ℝ)) |
| atTop (𝓝 (∑ p : ↥(allPositiveRoots (d+1) \ P), |
| max (ell p.val.1-ell p.val.2) 0 * canonicalRootCoefficient d μ p.val.1 p.val.2)) := by |
| let a := ρ * (∑ p : ↥(allPositiveRoots (d+1) \ P), |
| canonicalRootCoefficient d μ p.val.1 p.val.2) |
| let b := ∑ p : ↥(allPositiveRoots (d+1) \ P), |
| max (ell p.val.1-ell p.val.2) 0 * canonicalRootCoefficient d μ p.val.1 p.val.2 |
| have H : Tendsto (fun N : ℕ => a/(N:ℝ)+b) atTop (𝓝 b) := by |
| simpa only [zero_add] using |
| (tendsto_const_nhds.div_atTop tendsto_natCast_atTop_atTop : |
| Tendsto (fun N : ℕ => a/(N:ℝ)) atTop (𝓝 0)).add tendsto_const_nhds |
| apply H.congr' |
| filter_upwards [eventually_ge_atTop (1:ℕ)] with N hN |
| rw [c.integral_remainingBackwardTubeInformation hP hf ell hell ρ N μ hA] |
| change a/(N:ℝ)+b = (a+(N:ℝ)*b)/(N:ℝ) |
| have hn : (N:ℝ) ≠ 0 := by exact_mod_cast (show N ≠ 0 by omega) |
| field_simp |
| |
| end EliminationChain |
| end DukePrimeDegree |
| |
| end |
| |
| end OAI |
| |
