openAI-math-dataset / lean /OAI /Analysis /IrrationalRotation /Sampling /CharacterWeakConvergence.lean
| import OAI.Analysis.IrrationalRotation.Sampling.SeparatedCharacterFrequencies | |
| import Mathlib.Analysis.Fourier.AddCircleMulti | |
| import Mathlib.Topology.MetricSpace.Equicontinuity | |
| namespace OAI | |
| noncomputable section | |
| namespace Invariant233 | |
| namespace CharacterWeakConvergence | |
| open MeasureTheory Filter Set | |
| open scoped Topology NNReal | |
| section Integral | |
| variable {X Y : Type*} [TopologicalSpace X] [CompactSpace X] | |
| [TopologicalSpace Y] [CompactSpace Y] [MeasurableSpace X] [BorelSpace X] | |
| (μ : Measure X) [IsProbabilityMeasure μ] | |
| def pullbackIntegral (φ : C(X, Y)) : C(Y, ℂ) →L[ℂ] ℂ := | |
| let L : C(Y, ℂ) →ₗ[ℂ] ℂ := | |
| { toFun := fun f => ∫ x, f (φ x) ∂μ | |
| map_add' := by | |
| intro f g | |
| exact integral_add | |
| (f.continuous.comp φ.continuous |>.integrable_of_hasCompactSupport | |
| (HasCompactSupport.of_compactSpace _)) | |
| (g.continuous.comp φ.continuous |>.integrable_of_hasCompactSupport | |
| (HasCompactSupport.of_compactSpace _)) | |
| map_smul' := by | |
| intro c f | |
| simp only [ContinuousMap.smul_apply, integral_smul, RingHom.id_apply] } | |
| L.mkContinuous 1 (fun f => by | |
| have h := norm_integral_le_of_norm_le_const | |
| (μ := μ) (Filter.Eventually.of_forall (fun x => f.norm_coe_le_norm (φ x))) | |
| change ‖∫ x, f (φ x) ∂μ‖ ≤ 1 * ‖f‖ | |
| simpa using h) | |
| @[simp] theorem pullbackIntegral_apply (φ : C(X, Y)) (f : C(Y, ℂ)) : | |
| pullbackIntegral μ φ f = ∫ x, f (φ x) ∂μ := rfl | |
| theorem pullbackIntegral_norm_le (φ : C(X, Y)) : ‖pullbackIntegral μ φ‖ ≤ 1 := by | |
| apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one | |
| intro f | |
| have h := norm_integral_le_of_norm_le_const | |
| (μ := μ) (Filter.Eventually.of_forall (fun x => f.norm_coe_le_norm (φ x))) | |
| simpa using h | |
| end Integral | |
| theorem tendsto_of_dense_span | |
| {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] | |
| (L : ℕ → E →L[ℂ] ℂ) (M : E →L[ℂ] ℂ) (C : ℝ≥0) | |
| (hL : ∀ n, ‖L n‖₊ ≤ C) (s : Set E) | |
| (hs : (Submodule.span ℂ s).topologicalClosure = ⊤) | |
| (hconv : ∀ f ∈ s, Tendsto (fun n => L n f) atTop (𝓝 (M f))) | |
| (f : E) : Tendsto (fun n => L n f) atTop (𝓝 (M f)) := by | |
| let S : Submodule ℂ E := | |
| { carrier := {f | Tendsto (fun n => L n f) atTop (𝓝 (M f))} | |
| zero_mem' := by simp | |
| add_mem' := by | |
| intro f g hf hg | |
| simpa only [Set.mem_ofPred_eq, map_add] using hf.add hg | |
| smul_mem' := by | |
| intro c f hf | |
| simpa only [Set.mem_ofPred_eq, map_smul] using hf.const_smul c } | |
| have hclosed : IsClosed (S : Set E) := by | |
| apply Equicontinuous.isClosed_setOfPred_tendsto _ M.continuous | |
| exact (LipschitzWith.uniformEquicontinuous (fun n => (L n : E → ℂ)) C | |
| (fun n => (L n).lipschitzWith.weaken (hL n))).equicontinuous | |
| have hsS : Submodule.span ℂ s ≤ S := Submodule.span_le.mpr hconv | |
| have htop : (⊤ : Submodule ℂ E) ≤ S := by | |
| rw [← hs] | |
| exact Submodule.topologicalClosure_minimal _ hsS hclosed | |
| exact htop (Submodule.mem_top) | |
| local instance circleVolumeProbability : | |
| IsProbabilityMeasure (volume : Measure (AddCircle (1 : ℝ))) := | |
| ⟨by simp [AddCircle.measure_univ]⟩ | |
| theorem integral_mFourier_eq_zero {m : ℕ} {v : Fin m → ℤ} (hv : v ≠ 0) : | |
| (∫ y : UnitAddTorus (Fin m), UnitAddTorus.mFourier v y) = 0 := by | |
| change (∫ y : Fin m → AddCircle (1 : ℝ), ∏ i, fourier (v i) (y i)) = 0 | |
| rw [integral_fintype_prod_volume_eq_prod] | |
| obtain ⟨i, hi⟩ := Function.ne_iff.mp hv | |
| exact Finset.prod_eq_zero (Finset.mem_univ i) | |
| (SeparatedCharacterFrequencies.integral_fourier_eq_zero hi) | |
| theorem tendsto_integral_joint_characters | |
| (q : ℕ → ℕ → ℕ) (m : ℕ) | |
| (hq : ∀ j i, 0 < q j i) (hmono : ∀ j, Monotone (q j)) | |
| (hgap : ∀ i, i + 1 < m → Tendsto | |
| (fun j => (q j (i + 1) : ℝ) / (q j i : ℝ)) atTop atTop) | |
| (f : C(UnitAddTorus (Fin m), ℂ)) : | |
| Tendsto (fun j => ∫ x : AddCircle (1 : ℝ), | |
| f (fun i : Fin m => (q j i.val : ℤ) • x)) atTop | |
| (𝓝 (∫ y : UnitAddTorus (Fin m), f y)) := by | |
| let φ : ℕ → C(AddCircle (1 : ℝ), UnitAddTorus (Fin m)) := fun j => | |
| ⟨fun x i => (q j i.val : ℤ) • x, by fun_prop⟩ | |
| let L : ℕ → C(UnitAddTorus (Fin m), ℂ) →L[ℂ] ℂ := | |
| fun j => pullbackIntegral volume (φ j) | |
| let M : C(UnitAddTorus (Fin m), ℂ) →L[ℂ] ℂ := | |
| pullbackIntegral volume (ContinuousMap.id _) | |
| have hL : ∀ j, ‖L j‖₊ ≤ (1 : ℝ≥0) := by | |
| intro j | |
| exact_mod_cast pullbackIntegral_norm_le volume (φ j) | |
| have hconv : ∀ g ∈ Set.range (UnitAddTorus.mFourier (d := Fin m)), | |
| Tendsto (fun j => L j g) atTop (𝓝 (M g)) := by | |
| rintro _ ⟨v, rfl⟩ | |
| by_cases hv : v = 0 | |
| · subst v | |
| simp only [UnitAddTorus.mFourier_zero] | |
| simp [L, M, pullbackIntegral_apply] | |
| · let v' : ℕ → ℤ := fun n => if h : n < m then v ⟨n, h⟩ else 0 | |
| have hv' : ∃ i < m, v' i ≠ 0 := by | |
| obtain ⟨i, hi⟩ := Function.ne_iff.mp hv | |
| refine ⟨i.val, i.isLt, ?_⟩ | |
| simpa [v'] using hi | |
| have hprod : ∀ j (x : AddCircle (1 : ℝ)), | |
| UnitAddTorus.mFourier v (φ j x) = | |
| ∏ i ∈ Finset.range m, fourier (v' i) ((q j i : ℤ) • x) := by | |
| intro j x | |
| change (∏ i : Fin m, fourier (v i) ((q j i.val : ℤ) • x)) = _ | |
| simpa [v'] using Fin.prod_univ_eq_prod_range | |
| (fun i => fourier (v' i) ((q j i : ℤ) • x)) m | |
| have hevent : ∀ᶠ j in atTop, L j (UnitAddTorus.mFourier v) = 0 := by | |
| filter_upwards [SeparatedCharacterFrequencies.eventually_integral_product_fourier_eq_zero | |
| v' q m hq hmono hgap hv'] with j hj | |
| change (∫ x : AddCircle (1 : ℝ), UnitAddTorus.mFourier v (φ j x)) = 0 | |
| simpa only [hprod] using hj | |
| have hM : M (UnitAddTorus.mFourier v) = 0 := integral_mFourier_eq_zero hv | |
| rw [hM] | |
| exact tendsto_const_nhds.congr' (hevent.mono fun _ h => h.symm) | |
| exact tendsto_of_dense_span L M 1 hL _ | |
| UnitAddTorus.span_mFourier_closure_eq_top hconv f | |
| end CharacterWeakConvergence | |
| end Invariant233 | |
| end | |
| end OAI | |