| import OAI.Dynamics.TriangleBilliards.SmoothingLimits | |
| namespace OAI | |
| universe uE | |
| open MeasureTheory Set | |
| open scoped ENNReal symmDiff | |
| noncomputable section | |
| open MeasureTheory Set Filter Function Metric | |
| open scoped Topology Convolution ContDiff | |
| noncomputable section | |
| open MeasureTheory Set | |
| open scoped ENNReal | |
| noncomputable section | |
| open MeasureTheory Set Filter BoundedContinuousFunction | |
| open scoped ENNReal Topology ComplexConjugate | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped Topology ComplexConjugate | |
| noncomputable section | |
| open MeasureTheory Filter | |
| open scoped ComplexConjugate | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ComplexConjugate | |
| noncomputable section | |
| open Filter Finset Set | |
| open scoped Topology BigOperators | |
| noncomputable section | |
| open MeasureTheory Filter Set | |
| open scoped Topology ContDiff NNReal | |
| open MeasureTheory Filter Set | |
| open scoped Topology ComplexConjugate | |
| noncomputable section | |
| open Filter Set | |
| open scoped Topology | |
| noncomputable section | |
| namespace TriangularBilliards | |
| open Analysis Analytic SpatialSmoothing Filter Set | |
| open scoped Topology ComplexConjugate | |
| local instance : Fact (0 < 2 * Real.pi) := ⟨by positivity⟩ | |
| lemma smoothing_weak_limit (Q : Triangle) {ε : ℕ → ℝ} | |
| (hε : ∀ n, 0 < ε n) (he : Tendsto ε atTop (𝓝 0)) | |
| {u : ℕ → DoubleL2 Q} {H : ℝ} (hu : ∀ n, ‖u n‖ ≤ H) | |
| {g : DoubleL2 Q} (hg : WeaklyTendsto u atTop g) : | |
| WeaklyTendsto (fun n => smoothingLp Q (hε n) (u n)) atTop g := by | |
| apply weaklyTendsto_of_inner | |
| intro v | |
| have hh := (smoothing_variable_pairing Q hε he hu v).add (hg.inner_right v) | |
| simpa only [inner_sub_right,sub_add_cancel,zero_add] using hh | |
| noncomputable def clearanceCost (Q : Triangle) : ℝ := | |
| ((volume Q.table).toReal)⁻¹ * (3*(2*(Q.safetyFactor+1)+4)^2*Real.pi) | |
| lemma clearanceCost_nonneg (Q : Triangle) : 0 ≤ clearanceCost Q := by | |
| unfold clearanceCost | |
| positivity | |
| /-- The genuine fixed-s weak limit. The ε-dependent mode energy is allowed | |
| to grow as s goes to zero; no s-independent bound is used at this stage. -/ | |
| lemma clearance_first_limit (Q : Triangle) {H s : ℝ} (hH : 0 ≤ H) (hs : 0 < s) | |
| {f : DoubleL2 Q} (hf : ∀ᵐ z ∂doubleMeasure Q, ‖f z‖ ≤ H) | |
| (hinv : ∀ t, (geodesicHilbertFlow Q).act t f = f) | |
| (j : ℤ) {U B : DoubleL2 Q} | |
| (hUB : (geodesicHilbertFlow Q).HasGenerator U B) | |
| (hB : (angularCircleAction Q).projection (j-1) B = B) : | |
| ∃ g a b : DoubleL2 Q, | |
| (∀ᵐ z ∂doubleMeasure Q, ‖g z‖ ≤ H) ∧ | |
| (geodesicHilbertFlow Q).HasGenerator g 0 ∧ | |
| ‖g-f‖ ≤ H * (3*clearanceCost Q*s)^(1/2:ℝ) ∧ | |
| RotationalCR (geodesicHilbertFlow Q) (transverseHilbertFlow Q) (angularCircleAction Q) | |
| ((angularCircleAction Q).projection j g) a b ∧ inner ℂ B b = 0 := by | |
| let K := Q.safetyFactor+1 | |
| let L := 2*K+3 | |
| have hK : 0 < K := by dsimp [K]; linarith [Q.safetyFactor_pos] | |
| have hnb : ∀ᶠ ε : ℝ in 𝓝 0, 2*(K*ε)*Q.coordinateBound < 1 ∧ ε^2 < s := by | |
| have hc : Continuous (fun ε : ℝ => 2*(K*ε)*Q.coordinateBound) := by fun_prop | |
| have hd : Continuous (fun ε : ℝ => ε^2) := by fun_prop | |
| have hc₀ : ∀ᶠ ε : ℝ in 𝓝 0, 2*(K*ε)*Q.coordinateBound < 1 := by | |
| simpa using hc.continuousAt.eventually (gt_mem_nhds (by simp only [mul_zero,zero_mul]; norm_num)) | |
| have hd₀ : ∀ᶠ ε : ℝ in 𝓝 0, ε^2 < s := by | |
| simpa using hd.continuousAt.eventually (gt_mem_nhds (by simpa using hs)) | |
| exact hc₀.and hd₀ | |
| obtain ⟨δ,hδ,hball⟩ := Metric.eventually_nhds_iff.mp hnb | |
| obtain ⟨ε,_,hε,he⟩ := exists_seq_strictAnti_tendsto' hδ | |
| have hpos (n : ℕ) : 0 < ε n := (hε n).1 | |
| have hsmall (n : ℕ) : 2*(K*ε n)*Q.coordinateBound < 1 ∧ (ε n)^2 < s := hball | |
| (by simpa only [Real.dist_eq, sub_zero, abs_of_pos (hpos n)] using (hε n).2) | |
| have hT (n : ℕ) : 0 < s/ε n := div_pos hs (hpos n) | |
| have hR (n : ℕ) : Q.safetyFactor*ε n < K*ε n := by dsimp [K]; nlinarith [hpos n] | |
| have hL (n : ℕ) : 2*(K*ε n)+2*ε n ≤ L*ε n := by dsimp [L]; nlinarith [hpos n] | |
| have hd (n : ℕ) := exists_clearance_data Q (L:=L) (hpos n) (hT n) hH (hR n) | |
| (hsmall n).1 (hL n) hf hinv j hUB hB | |
| choose g w p a b hgb hclose hgp hpb hw hwb hcr hab hbb hpair using hd | |
| have hgn (n : ℕ) : ‖g n‖ ≤ H := doubleL2_norm_le_of_ae_bound Q hH (hgb n) | |
| have hpn : Tendsto p atTop (𝓝 0) := by | |
| apply squeeze_zero_norm _ (show Tendsto (fun n => (2*H/s)*ε n) atTop (𝓝 0) by | |
| simpa only [mul_zero] using he.const_mul (2*H/s)) | |
| intro n | |
| exact (hpb n).trans_eq (by field_simp) | |
| have hcost (n : ℕ) : (doubleMeasure Q (goodMesh Q L (ε n) (s/ε n))ᶜ).toReal ≤ | |
| 3*clearanceCost Q*s := by | |
| have hl : 0 ≤ L+1 := by dsimp [L]; linarith | |
| have hh := badMesh_real_bound Q hl (hpos n) (hT n).le | |
| have hC : ((volume Q.table).toReal)⁻¹*(3*(L+1)^2*Real.pi) = clearanceCost Q := by | |
| dsimp [clearanceCost,L]; congr 3; dsimp [K]; ring | |
| rw [hC,div_mul_cancel₀ _ (hpos n).ne'] at hh | |
| exact hh.trans (by nlinarith [mul_le_mul_of_nonneg_left (hsmall n).2.le (clearanceCost_nonneg Q)]) | |
| have hclosen (n : ℕ) : ‖g n-f‖ ≤ H*(3*clearanceCost Q*s)^(1/2:ℝ) := by | |
| apply (hclose n).trans | |
| gcongr | |
| exact hcost n | |
| let M := Real.sqrt (32*derivativeMass*H^2/s) | |
| have hM₀ : 0 ≤ 32*derivativeMass*H^2/s := by | |
| have := derivativeMass_nonneg | |
| positivity | |
| have hnorm {x : ℝ} {n : ℕ} (hx : x^2 ≤ 32*derivativeMass*H^2/((s/ε n)*ε n)) : x ≤ M := by | |
| rw [div_mul_cancel₀ _ (hpos n).ne'] at hx | |
| have hh := Real.sq_sqrt hM₀ | |
| have hh' := Real.sqrt_nonneg (32*derivativeMass*H^2/s) | |
| dsimp [M] | |
| nlinarith | |
| have han (n : ℕ) : ‖a n‖ ≤ M := hnorm (hab n) | |
| have hbn (n : ℕ) : ‖b n‖ ≤ M := hnorm (hbb n) | |
| have hpair0 : Tendsto (fun n => inner ℂ B (b n)) atTop (𝓝 0) := by | |
| have hy := scaled_smoothingY_norm_tendsto Q U hpos he | |
| have hlim := (he.const_mul (4*‖B‖*H/s)).add (hy.const_mul (H/s)) | |
| simp only [mul_zero,add_zero] at hlim | |
| apply squeeze_zero_norm _ hlim | |
| intro n | |
| exact (hpair n).trans_eq (by field_simp) | |
| let : InnerProductSpace ℝ (DoubleL2 Q) := InnerProductSpace.rclikeToReal ℂ _ | |
| obtain ⟨g₀,_,φ,hφ,hg₀⟩ := exists_weak_subsequence_unrestricted g hgn | |
| obtain ⟨a₀,_,ψ,hψ,ha₀⟩ := exists_weak_subsequence_unrestricted (a ∘ φ) (fun n => han (φ n)) | |
| obtain ⟨b₀,_,χ,hχ,hb₀⟩ := exists_weak_subsequence_unrestricted (b ∘ φ ∘ ψ) (fun n => hbn (φ (ψ n))) | |
| let κ := φ ∘ ψ ∘ χ | |
| have hκ : Tendsto κ atTop atTop := hφ.tendsto_atTop.comp (hψ.tendsto_atTop.comp hχ.tendsto_atTop) | |
| have hgl : WeaklyTendsto (g ∘ κ) atTop g₀ := hg₀.comp (hψ.tendsto_atTop.comp hχ.tendsto_atTop) | |
| have hal : WeaklyTendsto (a ∘ κ) atTop a₀ := ha₀.comp hχ.tendsto_atTop | |
| have hbl : WeaklyTendsto (b ∘ κ) atTop b₀ := hb₀ | |
| have hwl : WeaklyTendsto (w ∘ κ) atTop g₀ := by | |
| have hh := smoothing_weak_limit Q (fun n => hpos (κ n)) (he.comp hκ) (fun n => hgn (κ n)) hgl | |
| convert hh using 1 | |
| funext n | |
| exact hw (κ n) | |
| refine ⟨g₀,a₀,b₀,?_,?_,?_,?_,?_⟩ | |
| · exact hgl.mem_of_closed_convex (isClosed_ae_bounded H) (convex_ae_bounded H) | |
| (Eventually.of_forall fun n => hgb (κ n)) | |
| · exact HilbertFlow.HasGenerator.weak_limit (geodesicHilbertFlow Q) hgl | |
| (weaklyTendsto_of_tendsto (hpn.comp hκ)) (Eventually.of_forall fun n => hgp (κ n)) | |
| · exact (hgl.sub_const f).norm_le (Eventually.of_forall fun n => hclosen (κ n)) | |
| · exact RotationalCR.weak_limit (hwl.map (((angularCircleAction Q).projection j).restrictScalars ℝ)) | |
| hal hbl (fun n => hcr (κ n)) | |
| · exact tendsto_nhds_unique (hbl.inner_right B) (hpair0.comp hκ) | |
| end TriangularBilliards | |
| namespace TriangularBilliards.Analysis | |
| variable {E : Type uE} [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] | |
| omit [CompleteSpace E] in | |
| lemma HilbertFlow.HasGenerator.invariant {W : HilbertFlow E} {u : E} | |
| (h : W.HasGenerator u 0) (t : ℝ) : W.act t u = u := by | |
| have hh := h t | |
| rw [map_zero,sub_eq_zero] at hh | |
| exact hh | |
| omit [CompleteSpace E] in | |
| lemma HilbertFlow.hasGenerator_zero_iff (W : HilbertFlow E) (u : E) : | |
| W.HasGenerator u 0 ↔ ∀ t, W.act t u = u := by | |
| refine ⟨fun h => h.invariant, fun h t => ?_⟩ | |
| rw [h t,sub_self,map_zero] | |
| lemma RotationalCR.unique_pair {T : ℝ} [Fact (0 < T)] | |
| {X Y : HilbertFlow E} {V : CircleAction E T} {u a b c d : E} | |
| (h : RotationalCR X Y V u a b) (h' : RotationalCR X Y V u c d) : a=c ∧ b=d := | |
| CR_components_eq (X.generator_unique h.generators.1 h'.generators.1) | |
| (Y.generator_unique h.generators.2 h'.generators.2) | |
| end TriangularBilliards.Analysis | |
| namespace TriangularBilliards | |
| open Analysis Analytic SpatialSmoothing Filter Set | |
| open scoped Topology ComplexConjugate | |
| local instance : Fact (0 < 2 * Real.pi) := ⟨by positivity⟩ | |
| lemma exists_bounded_representative (Q : Triangle) {u : DoubleL2 Q} {H : ℝ} | |
| (hH : 0 ≤ H) (hu : ∀ᵐ z ∂doubleMeasure Q, ‖u z‖ ≤ H) : | |
| ∃ f : DoublePhase → ℂ, StronglyMeasurable f ∧ | |
| (∀ z, ‖f z‖ ≤ H) ∧ f =ᵐ[doubleMeasure Q] u := by | |
| classical | |
| let E := {z : DoublePhase | ‖u z‖ ≤ H} | |
| have hE : MeasurableSet E := | |
| measurableSet_le (Lp.stronglyMeasurable u).measurable.norm measurable_const | |
| refine ⟨E.indicator u,(Lp.stronglyMeasurable u).indicator hE,?_,?_⟩ | |
| · intro z | |
| by_cases hz : z ∈ E | |
| · simpa only [indicator_of_mem hz] using (show ‖u z‖ ≤ H from hz) | |
| · simpa only [indicator_of_notMem hz,norm_zero] using hH | |
| · filter_upwards [hu] with z hz | |
| exact indicator_of_mem (show z ∈ E from hz) _ | |
| lemma bounded_invariant_CR_ae (Q : Triangle) : | |
| ∃ C : ℝ, 0 ≤ C ∧ ∀ {H : ℝ} (_hH : 0 ≤ H) {f : DoubleL2 Q} | |
| (_hf : ∀ᵐ z ∂doubleMeasure Q, ‖f z‖ ≤ H) | |
| (_hfi : (geodesicHilbertFlow Q).HasGenerator f 0) (j : ℤ), | |
| ∃ a b : DoubleL2 Q, | |
| RotationalCR (geodesicHilbertFlow Q) (transverseHilbertFlow Q) | |
| (angularCircleAction Q) ((angularCircleAction Q).projection j f) a b ∧ | |
| ‖a‖ ≤ C*H ∧ ‖b‖ ≤ C*H := by | |
| obtain ⟨C,hC,hbound⟩ := bounded_invariant_CR Q | |
| refine ⟨C,hC,?_⟩ | |
| intro H hH f hf hfi j | |
| obtain ⟨f₀,hm,hb,he⟩ := exists_bounded_representative Q hH hf | |
| have hp : MemLp f₀ 2 (doubleMeasure Q) := (Lp.memLp f).ae_eq he.symm | |
| have hpeq : hp.toLp f₀ = f := Lp.ext (hp.coeFn_toLp.trans he) | |
| rw [← hpeq] at hfi ⊢ | |
| exact hbound hm hp hb hfi j | |
| /-- The second limit invokes the *exact invariant* uniform mode bound, | |
| not the fixed-s bound used before. -/ | |
| lemma clearance_second_limit (Q : Triangle) {H : ℝ} (hH : 0 ≤ H) | |
| {f : DoubleL2 Q} (hf : ∀ᵐ z ∂doubleMeasure Q, ‖f z‖ ≤ H) | |
| (hinv : ∀ t, (geodesicHilbertFlow Q).act t f = f) | |
| (j : ℤ) {a b U : DoubleL2 Q} | |
| (hcr : RotationalCR (geodesicHilbertFlow Q) (transverseHilbertFlow Q) | |
| (angularCircleAction Q) ((angularCircleAction Q).projection j f) a b) | |
| (hUb : (geodesicHilbertFlow Q).HasGenerator U b) : b=0 := by | |
| obtain ⟨C,hC,hbound⟩ := bounded_invariant_CR_ae Q | |
| obtain ⟨s,_,hs,he⟩ := exists_seq_strictAnti_tendsto' (by norm_num : (0:ℝ)<1) | |
| have hpos (n : ℕ) : 0 < s n := (hs n).1 | |
| have hmode := (hcr.mode_components ((angularCircleAction Q).projection_eigen j f)).2 | |
| have hd n := clearance_first_limit Q hH (hpos n) hf hinv j hUb hmode | |
| choose g a' b' hgb hgi hclose hcr' hpair using hd | |
| have hbounded (n : ℕ) : ‖a' n‖ ≤ C*H ∧ ‖b' n‖ ≤ C*H := by | |
| obtain ⟨a₀,b₀,hc,ha,hb⟩ := hbound hH (hgb n) (hgi n) j | |
| obtain ⟨rfl,rfl⟩ := (hcr' n).unique_pair hc | |
| exact ⟨ha,hb⟩ | |
| have hgstrong : Tendsto g atTop (𝓝 f) := by | |
| rw [tendsto_iff_norm_sub_tendsto_zero] | |
| have hzero := (he.const_mul (3*clearanceCost Q)).rpow_const (Or.inr (by norm_num : (0:ℝ) ≤ 1/2)) | |
| have hlim : Tendsto (fun n => H*(3*clearanceCost Q*s n)^(1/2:ℝ)) atTop (𝓝 0) := by | |
| simpa only [mul_zero,Real.zero_rpow (by norm_num : (1/2:ℝ) ≠ 0)] using hzero.const_mul H | |
| exact squeeze_zero (fun n => norm_nonneg _) hclose hlim | |
| let : InnerProductSpace ℝ (DoubleL2 Q) := InnerProductSpace.rclikeToReal ℂ _ | |
| obtain ⟨a₀,_,φ,hφ,ha₀⟩ := exists_weak_subsequence_unrestricted a' (fun n => (hbounded n).1) | |
| obtain ⟨b₀,_,ψ,hψ,hb₀⟩ := exists_weak_subsequence_unrestricted (b' ∘ φ) (fun n => (hbounded (φ n)).2) | |
| have hgweak := weaklyTendsto_of_tendsto (hgstrong.comp (hφ.tendsto_atTop.comp hψ.tendsto_atTop)) | |
| have hc := RotationalCR.weak_limit | |
| (hgweak.map (((angularCircleAction Q).projection j).restrictScalars ℝ)) | |
| (ha₀.comp hψ.tendsto_atTop) hb₀ (fun n => hcr' (φ (ψ n))) | |
| obtain ⟨_,hh⟩ := hcr.unique_pair hc | |
| have hp : inner ℂ b b₀ = 0 := tendsto_nhds_unique (hb₀.inner_right b) | |
| (by simpa only [Function.comp_def,hpair] using (tendsto_const_nhds : Tendsto (fun _ : ℕ => (0:ℂ)) atTop (𝓝 0))) | |
| rw [← hh] at hp | |
| exact inner_self_eq_zero.mp hp | |
| /-- Analytic rigidity, on the actual double of every nondegenerate triangle. | |
| No irrational-angle assumption is needed for this stage. -/ | |
| theorem bounded_invariant_rigidity (Q : Triangle) {H : ℝ} (hH : 0 ≤ H) | |
| {f : DoubleL2 Q} (hf : ∀ᵐ z ∂doubleMeasure Q, ‖f z‖ ≤ H) | |
| (hinv : ∀ t, (geodesicHilbertFlow Q).act t f = f) (j : ℤ) : | |
| RotationalCR (geodesicHilbertFlow Q) (transverseHilbertFlow Q) | |
| (angularCircleAction Q) ((angularCircleAction Q).projection j f) 0 0 := by | |
| have hfi := ((geodesicHilbertFlow Q).hasGenerator_zero_iff f).mpr hinv | |
| obtain ⟨f₀,hm,hb,he⟩ := exists_bounded_representative Q hH hf | |
| have hp : MemLp f₀ 2 (doubleMeasure Q) := (Lp.memLp f).ae_eq he.symm | |
| have hpeq : hp.toLp f₀ = f := Lp.ext (hp.coeFn_toLp.trans he) | |
| obtain ⟨_,_,htail⟩ := bounded_invariant_tail_endpoint Q | |
| obtain ⟨a,b,hcr,_,ht⟩ := htail hm hp hb (hpeq.symm ▸ hfi) | |
| simp only [hpeq] at hcr ht | |
| have hz (m : ℤ) : b m = 0 := clearance_second_limit Q hH hf hinv m (hcr m) (ht m) | |
| have ha : a j = 0 := by | |
| have hh := invariant_CR_recurrence (geodesicHilbertFlow Q) (transverseHilbertFlow Q) | |
| (angularCircleAction Q) (dense_rotationalCR_core Q) hfi a b hcr j | |
| simpa only [hz,add_zero] using hh | |
| simpa only [ha,hz] using hcr j | |
| end TriangularBilliards | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end | |
| end OAI | |