| import OAI.Dynamics.ThreeTorus.Preparation |
|
|
| namespace OAI |
|
|
| /-! Good-arc cutoffs, scalar and tensor packet constructors, fiber insertion, and initial dense tests. -/ |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology BigOperators ENNReal |
| namespace ThreeTorus |
|
|
| lemma sharp_cutoff_integral_bound {δ t : ℝ} (ht : 0 < t) (hδ : 0 ≤ δ) |
| (hu : δ+t < 1/2) {b : ℝ → ℝ} (hbc : Continuous b) (_hbs : HasCompactSupport b) |
| (hb : ∀ x, 0 ≤ b x ∧ b x ≤ 1) |
| (hone : ∀ x ∈ Icc (δ+t) (1-δ-t), b x = 1) : |
| (∫ x in Ioo (0:ℝ) 1, (1-b x)^2) ≤ 2*δ+2*t := by |
| have hbint : IntegrableOn (fun x : ℝ => b x^2) (Ioo (0:ℝ) 1) := |
| (hbc.pow 2).integrableOn_Icc.mono_set Ioo_subset_Icc_self |
| have hlower : 1-2*δ-2*t ≤ ∫ x in Ioo (0:ℝ) 1, b x^2 := by |
| calc |
| _ = ∫ x in Icc (δ+t) (1-δ-t), (1:ℝ) := by |
| simp only [integral_const,Measure.restrict_apply_univ,smul_eq_mul,mul_one, |
| Measure.real,Real.volume_Icc,ENNReal.toReal_ofReal (by linarith : 0 ≤ 1-δ-t-(δ+t))] |
| ring |
| _ = ∫ x in Icc (δ+t) (1-δ-t), b x^2 := by |
| apply setIntegral_congr_fun measurableSet_Icc |
| intro x hx |
| dsimp only |
| rw [hone x hx,one_pow] |
| _ ≤ ∫ x in Ioo (0:ℝ) 1, b x^2 := by |
| apply setIntegral_mono_set hbint (.of_forall fun _ => sq_nonneg _) |
| exact .of_forall fun x hx => ⟨by linarith [hx.1],by linarith [hx.2]⟩ |
| have hi : IntegrableOn (fun _ : ℝ => (1:ℝ)) (Ioo (0:ℝ) 1) := |
| continuous_const.integrableOn_Icc.mono_set Ioo_subset_Icc_self |
| calc |
| _ ≤ ∫ x in Ioo (0:ℝ) 1, 1-b x^2 := by |
| apply setIntegral_mono_on |
| ((continuous_const.sub hbc).pow 2 |>.integrableOn_Icc.mono_set Ioo_subset_Icc_self) |
| (hi.sub hbint) measurableSet_Ioo |
| intro x _ |
| change (1-b x)^2 ≤ 1-b x^2 |
| nlinarith [(hb x).1,(hb x).2] |
| _ = 1-∫ x in Ioo (0:ℝ) 1, b x^2 := by rw [integral_sub hi hbint]; simp |
| _ ≤ _ := by linarith |
|
|
| /-- Smooth compact arc cutoffs with arbitrarily small excess over the ACTUAL |
| complement length. The standard neutral 4δ estimate is not sharp enough here. -/ |
| theorem exists_sharp_arc_cutoff {δ t : ℝ} (hδ : 0 ≤ δ) (ht : 0 < t) |
| (hu : δ+t < 1/2) : |
| ∃ χ : ℝ → ℝ, ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) χ ∧ HasCompactSupport χ ∧ |
| tsupport χ ⊆ Ioo δ (1-δ) ∧ (∀ x, 0 ≤ χ x ∧ χ x ≤ 1) ∧ |
| (∀ x ∈ Icc (δ+t) (1-δ-t), χ x = 1) ∧ |
| (∫ x in Ioo (0:ℝ) 1, (1-χ x)^2) ≤ 2*δ+2*t := by |
| let b : ContDiffBump (1/2:ℝ) := ⟨1/2-δ-t,1/2-δ-t/2,by linarith,by linarith⟩ |
| have hs : tsupport (b : ℝ → ℝ) ⊆ Ioo δ (1-δ) := by |
| intro x hx |
| rw [b.tsupport_eq] at hx |
| change |x-1/2| ≤ 1/2-δ-t/2 at hx |
| have hh := abs_le.mp hx |
| constructor <;> linarith |
| have hone : ∀ x ∈ Icc (δ+t) (1-δ-t), b x = 1 := by |
| intro x hx |
| apply b.one_of_mem_closedBall |
| change |x-1/2| ≤ 1/2-δ-t |
| rw [abs_le] |
| constructor <;> linarith [hx.1,hx.2] |
| refine ⟨b,b.contDiff,b.hasCompactSupport,hs,fun x => ⟨b.nonneg,b.le_one⟩,hone,?_⟩ |
| exact sharp_cutoff_integral_bound ht hδ hu b.continuous b.hasCompactSupport |
| (fun _ => ⟨b.nonneg,b.le_one⟩) hone |
|
|
| lemma circle_cutoff_squared_error {χ : ℝ → ℝ} |
| (_hc : HasCompactSupport χ) (hs : support χ ⊆ Ioo (0:ℝ) 1) |
| (_hb : ∀ x, 0 ≤ χ x ∧ χ x ≤ 1) : |
| (∫ x, (1-(periodize_periodic χ).lift x)^2 ∂AddCircle.haarAddCircle) = |
| ∫ x in Ioo (0:ℝ) 1, (1-χ x)^2 := by |
| have he := AddCircle.integral_preimage 1 0 |
| (fun x : UnitAddCircle => (1-(periodize_periodic χ).lift x)^2) |
| simp only [zero_add,AddCircle.volume_eq_smul_haarAddCircle,ENNReal.ofReal_one,one_smul] at he |
| rw [← he,integral_Ioc_eq_integral_Ioo] |
| apply setIntegral_congr_fun measurableSet_Ioo |
| intro x hx |
| change (1-periodize χ x)^2 = (1-χ x)^2 |
| rw [periodize_eq_on_unit hs ⟨hx.1.le,hx.2.le⟩] |
|
|
| end ThreeTorus |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology BigOperators ComplexConjugate |
| namespace ThreeTorus |
|
|
| lemma cylinderTorusCutoff_scalar (χ : ℝ → ℝ) (p : UnitAddCircle × UnitAddCircle) : |
| cylinderTorusCutoff (fun q => χ q.1) p = (periodize_periodic χ).lift p.1 := by |
| rcases p with ⟨p,q⟩ |
| obtain ⟨x,hx⟩ := QuotientAddGroup.mk_surjective p |
| subst p |
| rfl |
|
|
| /-- A common scalar good-arc cutoff produces literal smooth input packets; |
| all data are fixed before any passage integer is chosen. -/ |
| theorem exists_scalar_cutoff_packets {ι : Type*} |
| (m : ι → ℤ) (hm : ∀ i, m i ≠ 0) |
| (C : ι → UnitAddCircle × UnitAddCircle → ℂ) |
| (hCc : ∀ i, Continuous (C i)) |
| (hCs : ∀ i, ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (fun p : ℝ × ℝ => C i (p.1,p.2))) |
| {χ : ℝ → ℝ} (hχs : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) χ) |
| (hχc : HasCompactSupport χ) {δ : ℝ} (hδ : 0 ≤ δ) (hd : δ < 1/2) |
| (hχI : tsupport χ ⊆ Ioo δ (1-δ)) |
| (V : ℝ → ℝ) (hVp : Periodic V 1) |
| (hVs : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) V) |
| (hVd : ∀ x ∈ Ioo δ (1-δ), 0 < deriv V x) : |
| ∃ F : PassagePackets ι, F.m=m ∧ F.V=V ∧ F.GoodArc δ ∧ |
| (∀ i p, F.A i p = ((periodize_periodic χ).lift p.1:ℂ)*C i p) ∧ |
| ∀ i a x, F.A₀ i a x = (χ x:ℂ)*C i ((x:UnitAddCircle),a) := by |
| obtain ⟨l,u,R,hdl,hlu,hud,hR,hKI,hbuffer⟩ := compact_inside_buffered_interval |
| hχc (by linarith : δ < 1-δ) hχI |
| have hs : CylinderSmooth (fun p : ℝ × UnitAddCircle => χ p.1) := hχs.comp contDiff_fst |
| have hc : HasCompactSupport (fun p : ℝ × UnitAddCircle => χ p.1) := scalar_cylinder_compact hχc |
| have hso : support (fun p : ℝ × UnitAddCircle => χ p.1) ⊆ Ioo (0:ℝ) (0+1) ×ˢ univ := by |
| intro p hp |
| have h := hχI (subset_tsupport χ hp) |
| exact ⟨⟨hδ.trans_lt h.1,by linarith [h.2]⟩,mem_univ _⟩ |
| have hsi : support (fun p : ℝ × UnitAddCircle => χ p.1) ⊆ Ioc l u ×ˢ univ := |
| fun p hp => ⟨hKI (subset_tsupport χ hp),mem_univ _⟩ |
| let F := cutoffPackets m hm C hCc hCs (fun _ p => χ p.1) (fun _ => hs) (fun _ => hc) |
| 0 l u R (fun _ => hso) (fun _ => hsi) (hδ.trans hdl.le) (by linarith) hlu.le hR |
| V hVp hVs (fun x hx => hVd x (hbuffer hx)) |
| refine ⟨F,rfl,rfl,⟨rfl,hdl,hud,hVd⟩,?_,fun _ _ _ => rfl⟩ |
| intro i p |
| change (cylinderTorusCutoff (fun q => χ q.1) p:ℂ)*C i p = _ |
| rw [cylinderTorusCutoff_scalar] |
|
|
| lemma scalar_packets_reflection {ι : Type*} (F : PassagePackets ι) |
| {τ : ι → ι} {m : ι → ℤ} {C : ι → UnitAddCircle × UnitAddCircle → ℂ} |
| {χ : ℝ → ℝ} (hm : F.m=m) (hmi : ∀ i, m (τ i) = -m i) |
| (hc : ∀ i p, C (τ i) p = conj (C i p)) |
| (hA : ∀ i p, F.A i p = ((periodize_periodic χ).lift p.1:ℂ)*C i p) |
| (hA₀ : ∀ i a x, F.A₀ i a x = (χ x:ℂ)*C i ((x:UnitAddCircle),a)) : |
| F.Reflection τ := by |
| constructor |
| · simpa only [hm] using hmi |
| · intro i p; rw [hA,hA,hc]; simp only [map_mul,Complex.conj_ofReal] |
| · intro i a x; rw [hA₀,hA₀,hc]; simp only [map_mul,Complex.conj_ofReal] |
|
|
| end ThreeTorus |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Function MeasureTheory |
| open scoped BigOperators ComplexConjugate |
| namespace ThreeTorus |
|
|
| lemma tensor_filter_reflection {c : TensorIndex →₀ ℂ} (hc : ∀ k, c (-k)=conj (c k)) |
| (P : TensorIndex → Prop) [DecidablePred P] (hP : ∀ k, P (-k) ↔ P k) : |
| ∀ k, (c.filter P) (-k)=conj ((c.filter P) k) := by |
| intro k |
| simp only [Finsupp.filter_apply,hP,hc,apply_ite,map_zero] |
| split_ifs <;> rfl |
|
|
| lemma tensorAngular_reflection {c : TensorIndex →₀ ℂ} (hc : ∀ k, c (-k)=conj (c k)) : |
| ∀ k, tensorAngular c (-k)=conj (tensorAngular c k) := |
| tensor_filter_reflection hc _ (fun _ => by simp) |
| lemma tensorMiddle_reflection {c : TensorIndex →₀ ℂ} (hc : ∀ k, c (-k)=conj (c k)) : |
| ∀ k, tensorMiddle c (-k)=conj (tensorMiddle c k) := |
| tensor_filter_reflection hc _ (fun _ => by simp) |
| lemma tensorLast_reflection {c : TensorIndex →₀ ℂ} (hc : ∀ k, c (-k)=conj (c k)) : |
| ∀ k, tensorLast c (-k)=conj (tensorLast c k) := |
| tensor_filter_reflection hc _ (fun _ => by simp) |
|
|
| def tensorSupportNeg {c : TensorIndex →₀ ℂ} (hc : ∀ k, c (-k)=conj (c k)) : |
| ↥c.support → ↥c.support := fun k => ⟨-k.val,by |
| rw [Finsupp.mem_support_iff,hc] |
| exact (map_ne_zero (starRingEnd ℂ)).mpr (Finsupp.mem_support_iff.mp k.property)⟩ |
|
|
| lemma tensorSupportNeg_involutive {c : TensorIndex →₀ ℂ} (hc : ∀ k, c (-k)=conj (c k)) : |
| Involutive (tensorSupportNeg hc) := fun _ => Subtype.ext (neg_neg _) |
|
|
| /-- Literal smooth packets of a finite tensor polynomial after a cyclic |
| coordinate change. The unused old coordinate is not silently discarded. -/ |
| theorem exists_rotated_tensor_packets (c : TensorIndex →₀ ℂ) |
| (hc : ∀ k, c (-k)=conj (c k)) (a b d : Fin 3) |
| (hn : ∀ k ∈ c.support, k a ≠ 0) |
| {χ : ℝ → ℝ} (hχs : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) χ) |
| (hχc : HasCompactSupport χ) {δ : ℝ} (hδ : 0 ≤ δ) (hd : δ < 1/2) |
| (hχI : tsupport χ ⊆ Ioo δ (1-δ)) |
| (V : ℝ → ℝ) (hVp : Periodic V 1) |
| (hVs : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) V) |
| (hVd : ∀ x ∈ Ioo δ (1-δ), 0 < deriv V x) : |
| ∃ F : PassagePackets ↥c.support, F.V=V ∧ F.GoodArc δ ∧ |
| F.Reflection (tensorSupportNeg hc) ∧ |
| (∀ k, F.m k=k.val a) ∧ |
| ∀ x, finitePacketVector F.m F.A x = ((periodize_periodic χ).lift x.2.1:ℂ)* |
| ∑ k ∈ c.support, c k*(fourier (k a) x.1*fourier (k b) x.2.1*fourier (k d) x.2.2) := by |
| let C : ↥c.support → UnitAddCircle × UnitAddCircle → ℂ := |
| fun k ua => c k.val*fourier (k.val b) ua.1*fourier (k.val d) ua.2 |
| have hCc k : Continuous (C k) := by dsimp [C]; fun_prop |
| have hCs k : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (fun p : ℝ × ℝ => C k (p.1,p.2)) := |
| (contDiff_const.mul ((smooth_fourier_lift (k.val b)).comp contDiff_fst)).mul |
| ((smooth_fourier_lift (k.val d)).comp contDiff_snd) |
| obtain ⟨F,hFm,hFV,hFg,hFA,hFA₀⟩ := exists_scalar_cutoff_packets |
| (fun k : ↥c.support => k.val a) (fun k => hn k.val k.property) C hCc hCs |
| hχs hχc hδ hd hχI V hVp hVs hVd |
| have hCr k p : C (tensorSupportNeg hc k) p=conj (C k p) := by |
| simp only [C,tensorSupportNeg,hc,Pi.neg_apply,fourier_neg,map_mul] |
| have hFr := scalar_packets_reflection F hFm (fun _ => rfl) hCr hFA hFA₀ |
| refine ⟨F,hFV,hFg,hFr,fun _ => congrFun hFm _,?_⟩ |
| intro x |
| simp only [finitePacketVector,packet,hFA,hFm,C] |
| rw [Finset.mul_sum] |
| change (∑ k ∈ c.support.attach, _) = _ |
| refine (Finset.sum_congr rfl (fun k _ => ?_)).trans |
| (Finset.sum_attach c.support (fun k => ((periodize_periodic χ).lift x.2.1:ℂ)* |
| (c k*(fourier (k a) x.1*fourier (k b) x.2.1*fourier (k d) x.2.2)))) |
| ring |
|
|
| end ThreeTorus |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology BigOperators ComplexConjugate ENNReal |
| namespace ThreeTorus |
|
|
| lemma tensorPolynomial_add (c d : TensorIndex →₀ ℂ) : |
| tensorPolynomial (c+d) = fun x => tensorPolynomial c x+tensorPolynomial d x := by |
| funext x |
| simp only [tensorPolynomial_eq,comp_apply,multiTrigPolynomial_add] |
| rfl |
|
|
| lemma tensorPolynomial_filter (c : TensorIndex →₀ ℂ) (p : TensorIndex → Prop) |
| [DecidablePred p] (x : TripleTorus) : |
| tensorPolynomial (c.filter p) x = ∑ k ∈ c.support, if p k then c k*tensorCharacter k x else 0 := by |
| classical |
| simp only [tensorPolynomial,Finsupp.sum,Finsupp.support_filter,Finset.sum_filter] |
| apply Finset.sum_congr rfl |
| intro k _ |
| by_cases h : p k <;> simp [h] |
|
|
| lemma tensorCharacter_angular_integral (k : TensorIndex) (ua : UnitAddCircle × UnitAddCircle) : |
| (∫ θ, tensorCharacter k (θ,ua) ∂phaseHaar) = |
| if k 0=0 then fourier (k 1) ua.1*fourier (k 2) ua.2 else 0 := by |
| simp only [tensorCharacter,integral_mul_const,integral_fourier_haar] |
| split_ifs <;> simp_all |
|
|
| lemma tensorAngular_eq_remove_mean (c : TensorIndex →₀ ℂ) (x : TripleTorus) : |
| tensorPolynomial (tensorAngular c) x = |
| tensorPolynomial c x-∫ θ, tensorPolynomial c (θ,x.2) ∂phaseHaar := by |
| classical |
| have hsplit : ∀ k, (if k 0≠0 then c k*tensorCharacter k x else 0) = |
| c k*tensorCharacter k x-c k*(if k 0=0 then fourier (k 1) x.2.1*fourier (k 2) x.2.2 else 0) := by |
| intro k |
| by_cases hk : k 0=0 |
| · simp [hk,tensorCharacter] |
| · simp [hk] |
| rw [tensorAngular,tensorPolynomial_filter] |
| simp_rw [hsplit] |
| rw [Finset.sum_sub_distrib] |
| congr 1 |
| change _ = ∫ θ, ∑ k ∈ c.support, c k*tensorCharacter k (θ,x.2) ∂phaseHaar |
| rw [integral_finsetSum] |
| · apply Finset.sum_congr rfl |
| intro k _ |
| rw [integral_const_mul,tensorCharacter_angular_integral] |
| · intro k _ |
| exact (continuous_const.mul ((tensorCharacter_continuous k).comp |
| (continuous_id.prodMk continuous_const))).integrable_of_hasCompactSupport |
| (HasCompactSupport.of_compactSpace _) |
|
|
| lemma tensorAngular_fiber_energy_le (c : TensorIndex →₀ ℂ) {B : ℝ} (_hB : 0 ≤ B) |
| (hc : ∀ x, ‖tensorPolynomial c x‖ ≤ B) (ua : UnitAddCircle × UnitAddCircle) : |
| (∫ θ, ‖tensorPolynomial (tensorAngular c) (θ,ua)‖^2 ∂phaseHaar) ≤ B^2 := by |
| have hcont : Continuous (fun θ => tensorPolynomial c (θ,ua)) := |
| (tensorPolynomial_continuous c).comp (continuous_id.prodMk continuous_const) |
| simp_rw [tensorAngular_eq_remove_mean] |
| have hf := hcont.memLp_of_hasCompactSupport (p := 2) (μ := phaseHaar) (HasCompactSupport.of_compactSpace _) |
| refine (integral_sq_sub_mean_le hf).trans ?_ |
| have he : (∫ θ : UnitAddCircle, B^2 ∂phaseHaar) = B^2 := by simp |
| rw [← he] |
| apply integral_mono (hcont.norm.pow 2 |>.integrable_of_hasCompactSupport |
| (HasCompactSupport.of_compactSpace _)) (integrable_const _) |
| intro θ |
| exact pow_le_pow_left₀ (norm_nonneg _) (hc (θ,ua)) 2 |
|
|
| /-- Exact constant-one angular cutoff bound; it is the actual lost arc length, |
| not four times that length, which appears in the preparation error. -/ |
| lemma tensorAngular_cutoff_energy (c : TensorIndex →₀ ℂ) {B : ℝ} (hB : 0 ≤ B) |
| (hc : ∀ x, ‖tensorPolynomial c x‖ ≤ B) {χ : UnitAddCircle → ℝ} (hχ : Continuous χ) : |
| (∫ x : TripleTorus, ‖tensorPolynomial (tensorAngular c) x- |
| (χ x.2.1:ℂ)*tensorPolynomial (tensorAngular c) x‖^2 ∂tripleVolume) ≤ |
| B^2 * ∫ u, (1-χ u)^2 ∂phaseHaar := by |
| let f := tensorPolynomial (tensorAngular c) |
| have hfc : Continuous f := tensorPolynomial_continuous _ |
| have he (x : TripleTorus) : ‖f x-(χ x.2.1:ℂ)*f x‖^2 = (1-χ x.2.1)^2*‖f x‖^2 := by |
| rw [show f x-(χ x.2.1:ℂ)*f x = ((1-χ x.2.1:ℝ):ℂ)*f x by push_cast; ring, |
| norm_mul,Complex.norm_real,Real.norm_eq_abs,mul_pow,sq_abs] |
| change (∫ x : TripleTorus, ‖f x-(χ x.2.1:ℂ)*f x‖^2 ∂tripleVolume) ≤ _ |
| simp_rw [he] |
| have hi : Integrable (fun x : TripleTorus => (1-χ x.2.1)^2*‖f x‖^2) tripleVolume := |
| (((continuous_const.sub (hχ.comp (continuous_fst.comp continuous_snd))).pow 2).mul |
| (hfc.norm.pow 2)).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| rw [integral_prod_symm _ hi] |
| simp_rw [integral_const_mul] |
| calc |
| _ ≤ ∫ ua, (1-χ ua.1)^2*B^2 ∂slowVolume := by |
| apply integral_mono (by simpa only [integral_const_mul] using hi.integral_prod_right) |
| ((((continuous_const.sub (hχ.comp continuous_fst)).pow 2).mul continuous_const).integrable_of_hasCompactSupport |
| (HasCompactSupport.of_compactSpace _)) |
| intro ua |
| exact mul_le_mul_of_nonneg_left (tensorAngular_fiber_energy_le c hB hc ua) (sq_nonneg _) |
| _ = _ := by |
| rw [integral_prod] |
| · simp only [integral_const,probReal_univ,one_smul] |
| rw [integral_mul_const,mul_comm] |
| · exact (((continuous_const.sub (hχ.comp continuous_fst)).pow 2).mul continuous_const).integrable_of_hasCompactSupport |
| (HasCompactSupport.of_compactSpace _) |
|
|
| end ThreeTorus |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology BigOperators ComplexConjugate |
| namespace ThreeTorus |
|
|
| lemma neutralCircleCutoff_squared_error {δ : ℝ} (cut : LawCutoffs δ) |
| (hδ : 0 < δ) (hd : δ < 1/8) : |
| (∫ a, (1-neutralCircleCutoff cut a)^2 ∂phaseHaar) ≤ 4*δ := by |
| have hs : support cut.ψ ⊆ Ioo (0:ℝ) 1 := fun x hx => by |
| have hh := cut.ψ_support (subset_tsupport _ hx) |
| exact ⟨hδ.trans hh.1,by linarith [hh.2]⟩ |
| change (∫ a, (1-(periodize_periodic cut.ψ).lift a)^2 ∂phaseHaar) ≤ _ |
| rw [circle_cutoff_squared_error cut.ψ_compact hs (fun x => ⟨cut.ψ_nonneg x,cut.ψ_le_one x⟩)] |
| have hh := sharp_cutoff_integral_bound hδ hδ.le (by linarith : δ+δ < 1/2) |
| cut.ψ_smooth.continuous cut.ψ_compact (fun x => ⟨cut.ψ_nonneg x,cut.ψ_le_one x⟩) |
| (by simpa only [two_mul,sub_sub] using cut.ψ_one) |
| linarith |
|
|
| lemma uniform_slow_cutoff_energy {f : TripleTorus → ℂ} (hf : Continuous f) |
| {B : ℝ} (_hB : 0 ≤ B) (hb : ∀ x, ‖f x‖ ≤ B) |
| {χ : UnitAddCircle → ℝ} (hχ : Continuous χ) : |
| physicalError f (fun x => (χ x.2.1:ℂ)*f x) ≤ |
| B^2*(∫ u, (1-χ u)^2 ∂phaseHaar) := by |
| have he (x : TripleTorus) : ‖f x-(χ x.2.1:ℂ)*f x‖^2 = (1-χ x.2.1)^2*‖f x‖^2 := by |
| rw [show f x-(χ x.2.1:ℂ)*f x = ((1-χ x.2.1:ℝ):ℂ)*f x by push_cast; ring, |
| norm_mul,Complex.norm_real,Real.norm_eq_abs,mul_pow,sq_abs] |
| unfold physicalError |
| simp_rw [he] |
| calc |
| _ ≤ ∫ x : TripleTorus, (1-χ x.2.1)^2*B^2 ∂tripleVolume := by |
| apply integral_mono |
| (((continuous_const.sub (hχ.comp (continuous_fst.comp continuous_snd))).pow 2).mul (hf.norm.pow 2) |
| |>.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _)) |
| (((continuous_const.sub (hχ.comp (continuous_fst.comp continuous_snd))).pow 2).mul continuous_const |
| |>.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _)) |
| intro x |
| exact mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (norm_nonneg _) (hb x) 2) (sq_nonneg _) |
| _ = _ := by |
| rw [integral_prod] |
| · simp only [integral_const,probReal_univ,one_smul] |
| rw [integral_prod] |
| · simp only [integral_const,probReal_univ,one_smul] |
| rw [integral_mul_const,mul_comm] |
| · exact (((continuous_const.sub (hχ.comp continuous_fst)).pow 2).mul continuous_const).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
| · exact (((continuous_const.sub (hχ.comp (continuous_fst.comp continuous_snd))).pow 2).mul continuous_const).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
|
|
| lemma tensorMiddle_coords {c : TensorIndex →₀ ℂ} (H : UnitAddCircle → UnitAddCircle) (x : TripleTorus) : |
| (∑ k ∈ (tensorMiddle c).support, tensorMiddle c k*(fourier (k 1) (passageChart H x).1 * |
| fourier (k 2) (passageChart H x).2.1 * fourier (k 0) (passageChart H x).2.2)) = |
| tensorPolynomial (tensorMiddle c) x := by |
| classical |
| unfold tensorPolynomial Finsupp.sum |
| apply Finset.sum_congr rfl |
| intro k hk |
| have hh := Finsupp.mem_support_iff.mp hk |
| have hk0 : k 0=0 := by |
| simpa only [tensorMiddle,Finsupp.filter_apply] using |
| (show k 0=0 from by |
| by_contra hn |
| exact hh (by simp [tensorMiddle,hn])) |
| simp only [tensorCharacter,passageChart,circleThetaShear,circleCycle,Equiv.trans_apply,Equiv.coe_fn_mk,hk0,fourier_zero,one_mul,mul_one] |
|
|
| lemma tensorLast_coords {c : TensorIndex →₀ ℂ} (H J : UnitAddCircle → UnitAddCircle) (x : TripleTorus) : |
| (∑ k ∈ (tensorLast c).support, tensorLast c k*(fourier (k 2) (passageChart J (passageChart H x)).1 * |
| fourier (k 0) (passageChart J (passageChart H x)).2.1 * |
| fourier (k 1) (passageChart J (passageChart H x)).2.2)) = tensorPolynomial (tensorLast c) x := by |
| classical |
| unfold tensorPolynomial Finsupp.sum |
| apply Finset.sum_congr rfl |
| intro k hk |
| have hh := Finsupp.mem_support_iff.mp hk |
| have hk01 : k 0=0 ∧ k 1=0 := by |
| by_contra hn |
| exact hh (by simp [tensorLast,hn]) |
| simp only [tensorCharacter,passageChart,circleThetaShear,circleCycle,Equiv.trans_apply,Equiv.coe_fn_mk,hk01.1,hk01.2,fourier_zero,one_mul,mul_one] |
|
|
| end ThreeTorus |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology BigOperators ComplexConjugate |
| namespace ThreeTorus |
|
|
| def rotatedTensor (c : TensorIndex →₀ ℂ) (a b d : Fin 3) (x : TripleTorus) : ℂ := |
| ∑ k ∈ c.support, c k*(fourier (k a) x.1*fourier (k b) x.2.1*fourier (k d) x.2.2) |
| def tensorBudget (c : TensorIndex →₀ ℂ) : ℝ := ∑ k ∈ c.support, ‖c k‖ |
| lemma tensorBudget_nonneg (c : TensorIndex →₀ ℂ) : 0 ≤ tensorBudget c := |
| Finset.sum_nonneg (fun _ _ => norm_nonneg _) |
| lemma rotatedTensor_continuous (c : TensorIndex →₀ ℂ) (a b d : Fin 3) : |
| Continuous (rotatedTensor c a b d) := by |
| unfold rotatedTensor |
| apply continuous_finsetSum |
| intro k _ |
| fun_prop |
| lemma rotatedTensor_norm_le (c : TensorIndex →₀ ℂ) (a b d : Fin 3) (x : TripleTorus) : |
| ‖rotatedTensor c a b d x‖ ≤ tensorBudget c := by |
| apply (norm_sum_le _ _).trans_eq |
| simp only [norm_mul,fourier_apply,Circle.norm_coe,mul_one,tensorBudget] |
|
|
| lemma exists_tensor_cutoff_family (c : TensorIndex →₀ ℂ) |
| (hc : ∀ k, c (-k)=conj (c k)) (a b d : Fin 3) |
| (hn : ∀ k ∈ c.support, k a ≠ 0) |
| {δ : ℝ} (hδ : 0 < δ) (hd : δ < 1/8) (cut : LawCutoffs δ) |
| (V : ℝ → ℝ) (hp : Periodic V 1) (hs : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) V) |
| (hv : ∀ x ∈ Ioo δ (1-δ), 0 < deriv V x) : |
| ∃ P : RealPacketFamily, P.data.V=V ∧ P.data.GoodArc δ ∧ |
| physicalError (rotatedTensor c a b d) P.vector ≤ 4*δ*(tensorBudget c)^2 := by |
| obtain ⟨P,hPV,hPg,hPr,_hPm,hPv⟩ := exists_rotated_tensor_packets c hc a b d hn |
| cut.ψ_smooth cut.ψ_compact hδ.le (by linarith : δ < 1/2) cut.ψ_support V hp hs hv |
| let F : RealPacketFamily := ⟨↥c.support,inferInstance,P,tensorSupportNeg hc, |
| tensorSupportNeg_involutive hc,hPr⟩ |
| refine ⟨F,hPV,hPg,?_⟩ |
| have he : F.vector = fun x => (neutralCircleCutoff cut x.2.1:ℂ)*rotatedTensor c a b d x := funext hPv |
| rw [he] |
| apply (uniform_slow_cutoff_energy (rotatedTensor_continuous c a b d) |
| (tensorBudget_nonneg c) (rotatedTensor_norm_le c a b d) (continuous_neutralCircleCutoff cut)).trans |
| have h := mul_le_mul_of_nonneg_left (neutralCircleCutoff_squared_error cut hδ hd) |
| (sq_nonneg (tensorBudget c)) |
| nlinarith |
|
|
| lemma tensorAngular_nonzero {c : TensorIndex →₀ ℂ} {k : TensorIndex} |
| (hk : k ∈ (tensorAngular c).support) : k 0 ≠ 0 := by |
| have hh := Finsupp.mem_support_iff.mp hk |
| intro hn |
| exact hh (by simp [tensorAngular,hn]) |
| lemma tensorMiddle_nonzero {c : TensorIndex →₀ ℂ} {k : TensorIndex} |
| (hk : k ∈ (tensorMiddle c).support) : k 1 ≠ 0 := by |
| classical |
| have hh := Finsupp.mem_support_iff.mp hk |
| intro hn |
| exact hh (by simp [tensorMiddle,hn]) |
|
|
| lemma tensor_split_vector (c : TensorIndex →₀ ℂ) (x : TripleTorus) : |
| tensorPolynomial c x=tensorPolynomial (tensorAngular c) x+ |
| tensorPolynomial (tensorMiddle c) x+tensorPolynomial (tensorLast c) x := by |
| have hs := congrArg (fun q => tensorPolynomial q x) (tensor_split c) |
| unfold tensorPolynomial at hs |
| rw [Finsupp.sum_add_index' (by simp) (by intros; ring), |
| Finsupp.sum_add_index' (by simp) (by intros; ring)] at hs |
| exact hs.symm |
| end ThreeTorus |
| end |
| end |
|
|
| section |
|
|
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology BigOperators ComplexConjugate |
| namespace ThreeTorus |
|
|
| lemma continuous_triple_memLp {f : TripleTorus → ℂ} (hf : Continuous f) : MemLp f 2 tripleVolume := |
| hf.memLp_of_hasCompactSupport (HasCompactSupport.of_compactSpace _) |
|
|
| lemma exists_cutoff_loss_budget (B : ℝ) {ε : ℝ} (he : 0 < ε) : |
| ∃ η : ℝ, 0 < η ∧ ∀ δ : ℝ, δ < η → 4*δ*B^2 < ε^2 := by |
| refine ⟨ε^2/(4*(B^2+1)),by positivity,?_⟩ |
| intro δ hd |
| have hh := (lt_div_iff₀ (by positivity : 0 < 4*(B^2+1))).1 hd |
| by_cases hδ : 0 ≤ δ |
| · nlinarith [sq_nonneg B] |
| · have : δ < 0 := lt_of_not_ge hδ |
| have : 4*δ*B^2 ≤ 0 := mul_nonpos_of_nonpos_of_nonneg (by linarith) (sq_nonneg B) |
| exact this.trans_lt (sq_pos_of_pos he) |
|
|
| /-- Two literal neutral passages convert both retained slow Fourier components |
| into nonzero angular packets. The F list alone is kept orthogonal. All objects, |
| cutoffs and bounds are fixed before their respective passage integer choices. -/ |
| theorem exists_two_slow_insertions (F H : RealPacketFamily) (hmi : Injective F.data.m) |
| {δ : ℝ} (hδ : 0 ≤ δ) (hgF : F.data.GoodArc δ) (hgH : H.data.GoodArc δ) (hV : H.data.V=F.data.V) |
| (c : TensorIndex →₀ ℂ) (hc0 : c 0=0) (hcr : ∀ k, c (-k)=conj (c k)) |
| (Q : PhysicalJetData) (frame : PhysicalFrame) |
| {ε κ ζ : ℝ} (hε : 0 < ε) (hκ : 0 < κ) (hζ : 0 < ζ) : |
| ∃ F' H' : RealPacketFamily, ∃ α : Equiv.Perm TripleTorus, ∃ frame' : PhysicalFrame, |
| Continuous α ∧ MeasurePreserving α tripleVolume tripleVolume ∧ |
| frame'.chart=frame.chart.trans α ∧ H'.data.V=F'.data.V ∧ Injective F'.data.m ∧ |
| (∃ δ' : ℝ, 0 < δ' ∧ δ' < 1/8 ∧ δ' < κ ∧ F'.data.GoodArc δ' ∧ H'.data.GoodArc δ') ∧ |
| Q.Close ζ frame F.data.V frame' F'.data.V ∧ |
| physicalDist F.vector (F'.vector ∘ α) < ε ∧ |
| physicalDist (fun x => H.vector x+tensorPolynomial (tensorMiddle c) x+tensorPolynomial (tensorLast c) x) |
| (H'.vector ∘ α) < ε ∧ |
| (∫ z, |F'.density z-F.density z| ∂phaseHaar) < ε := by |
| classical |
| let e := ε/4 |
| have he : 0 < e := by dsimp [e]; positivity |
| obtain ⟨η,hη,hηe⟩ := exists_cutoff_loss_budget (tensorBudget (tensorMiddle c)) he |
| obtain ⟨s,F₁,H₁,hF₁V,hH₁V,hF₁g,hH₁g,hsδ,hsjet,hF₁i,hsF,hsH,hsp⟩ := |
| exists_neutral_families F H hmi hδ hgF hgH hV Q frame he hη (half_pos hζ) |
| obtain ⟨P₁,hP₁V,hP₁g,hP₁e⟩ := exists_tensor_cutoff_family (tensorMiddle c) |
| (tensorMiddle_reflection hcr) 1 2 0 (fun _ => tensorMiddle_nonzero) |
| s.δpos s.δsmall s.cut s.final.V s.final.periodic s.final.smooth_speed s.good.2.2.2 |
| let K := H₁.append P₁ s.δpos.le hH₁g hP₁g (hP₁V.trans hH₁V.symm) |
| have hKg : K.data.GoodArc s.δ := H₁.data.append_good P₁.data s.δpos.le hH₁g hP₁g (hP₁V.trans hH₁V.symm) |
| have hKV : K.data.V=F₁.data.V := hH₁V.trans hF₁V.symm |
| obtain ⟨η₂,hη₂,hη₂e⟩ := exists_cutoff_loss_budget (tensorBudget (tensorLast c)) he |
| obtain ⟨t,F₂,H₂,hF₂V,hH₂V,hF₂g,hH₂g,htδ,htjet,hF₂i,htF,htH,htp⟩ := |
| exists_neutral_families F₁ K hF₁i s.δpos.le hF₁g hKg hKV Q (s.nextFrame frame) |
| he (lt_min hκ hη₂) (half_pos hζ) |
| obtain ⟨P₂,hP₂V,hP₂g,hP₂e⟩ := exists_tensor_cutoff_family (tensorLast c) |
| (tensorLast_reflection hcr) 2 0 1 (fun _ => tensorLast_nonzero hc0) |
| t.δpos t.δsmall t.cut t.final.V t.final.periodic t.final.smooth_speed t.good.2.2.2 |
| let H' := H₂.append P₂ t.δpos.le hH₂g hP₂g (hP₂V.trans hH₂V.symm) |
| have hscont : Continuous s.chart := continuous_passageChart (s.geometry.Hcontinuous s.n) |
| have htcont : Continuous t.chart := continuous_passageChart (t.geometry.Hcontinuous t.n) |
| have hsmp : MeasurePreserving s.chart tripleVolume tripleVolume := measurePreserving_passageChart (s.geometry.Hcontinuous s.n).measurable |
| have htmp : MeasurePreserving t.chart tripleVolume tripleVolume := measurePreserving_passageChart (t.geometry.Hcontinuous t.n).measurable |
| refine ⟨F₂,H',s.chart.trans t.chart,t.nextFrame (s.nextFrame frame),htcont.comp hscont,htmp.comp hsmp,rfl, |
| hH₂V.trans hF₂V.symm,hF₂i,⟨t.δ,t.δpos,t.δsmall,htδ.trans_le (min_le_left _ _),hF₂g,?_⟩,?_,?_,?_,?_⟩ |
| · exact H₂.data.append_good P₂.data t.δpos.le hH₂g hP₂g (hP₂V.trans hH₂V.symm) |
| · have hh := hsjet.trans htjet |
| convert hh using 1; simp [show ζ/2+ζ/2=ζ by ring] |
| · have htF' : physicalDist (F₁.vector ∘ s.chart) (F₂.vector ∘ (s.chart.trans t.chart)) < e := by |
| change physicalDist (F₁.vector ∘ s.chart) ((F₂.vector ∘ t.chart) ∘ s.chart) < e |
| rwa [physicalDist_continuous_comp s.chart hscont hsmp] |
| have hh := physicalDist_triangle F.vector_memLp (continuous_triple_memLp (F₁.continuous_vector.comp hscont)) |
| (continuous_triple_memLp (F₂.continuous_vector.comp (htcont.comp hscont))) |
| exact (hh.trans_lt (add_lt_add hsF htF')).trans_le (by dsimp [e]; linarith) |
| · have hm : (rotatedTensor (tensorMiddle c) 1 2 0 ∘ s.chart)=tensorPolynomial (tensorMiddle c) := |
| funext (tensorMiddle_coords (s.geometry.H s.n)) |
| have hl : (rotatedTensor (tensorLast c) 2 0 1 ∘ (s.chart.trans t.chart))=tensorPolynomial (tensorLast c) := |
| funext (tensorLast_coords (s.geometry.H s.n) (t.geometry.H t.n)) |
| have hP₁ : physicalDist (tensorPolynomial (tensorMiddle c)) (P₁.vector ∘ s.chart) < e := by |
| rw [← hm,physicalDist_continuous_comp s.chart hscont hsmp] |
| exact (physicalDist_lt_iff _ _ he).2 (hP₁e.trans_lt (hηe _ hsδ)) |
| have hP₂ : physicalDist (tensorPolynomial (tensorLast c)) (P₂.vector ∘ (s.chart.trans t.chart)) < e := by |
| rw [← hl,physicalDist_continuous_comp (s.chart.trans t.chart) (htcont.comp hscont) (htmp.comp hsmp)] |
| exact (physicalDist_lt_iff _ _ he).2 (hP₂e.trans_lt (hη₂e _ (htδ.trans_le (min_le_right _ _)))) |
| have hK : physicalDist (fun x => H.vector x+tensorPolynomial (tensorMiddle c) x) (K.vector ∘ s.chart) < e+e := by |
| have hh := physicalDist_add_le H.vector_memLp (continuous_triple_memLp (H₁.continuous_vector.comp hscont)) |
| (continuous_triple_memLp (tensorPolynomial_continuous (tensorMiddle c))) (continuous_triple_memLp (P₁.continuous_vector.comp hscont)) |
| have hv := H₁.append_vector P₁ s.δpos.le hH₁g hP₁g (hP₁V.trans hH₁V.symm) |
| change K.vector = _ at hv |
| rw [hv] |
| exact hh.trans_lt (add_lt_add hsH hP₁) |
| have hT : physicalDist (K.vector ∘ s.chart) (H₂.vector ∘ (s.chart.trans t.chart)) < e := by |
| change physicalDist (K.vector ∘ s.chart) ((H₂.vector ∘ t.chart) ∘ s.chart) < e |
| rwa [physicalDist_continuous_comp s.chart hscont hsmp] |
| have hKH : physicalDist (fun x => H.vector x+tensorPolynomial (tensorMiddle c) x) |
| (H₂.vector ∘ (s.chart.trans t.chart)) < (e+e)+e := |
| (physicalDist_triangle (continuous_triple_memLp (H.continuous_vector.add (tensorPolynomial_continuous (tensorMiddle c)))) |
| (continuous_triple_memLp (K.continuous_vector.comp hscont)) |
| (continuous_triple_memLp (H₂.continuous_vector.comp (htcont.comp hscont)))).trans_lt (add_lt_add hK hT) |
| have hh := physicalDist_add_le (continuous_triple_memLp (H.continuous_vector.add (tensorPolynomial_continuous (tensorMiddle c)))) |
| (continuous_triple_memLp (H₂.continuous_vector.comp (htcont.comp hscont))) |
| (continuous_triple_memLp (tensorPolynomial_continuous (tensorLast c))) |
| (continuous_triple_memLp (P₂.continuous_vector.comp (htcont.comp hscont))) |
| have hv := H₂.append_vector P₂ t.δpos.le hH₂g hP₂g (hP₂V.trans hH₂V.symm) |
| change H'.vector = _ at hv |
| rw [hv] |
| convert hh.trans_lt (add_lt_add hKH hP₂) using 1 <;> first | rfl | (simp only [e]; ring) |
| · have hh := densityDist_triangle F₂.density_integrable F₁.density_integrable F.density_integrable |
| have ht := hh.trans_lt (add_lt_add htp hsp) |
| dsimp [e] at ht |
| linarith |
| end ThreeTorus |
| end |
| end |
| |
| section |
| |
| noncomputable section |
| open Set Function Filter MeasureTheory |
| open scoped Topology BigOperators ComplexConjugate |
| namespace ThreeTorus |
| |
| lemma physicalDist_le_of_uniform {f g : TripleTorus → ℂ} (hf : Continuous f) (hg : Continuous g) |
| {e : ℝ} (he : 0 ≤ e) (h : ∀ x, ‖f x-g x‖ ≤ e) : physicalDist f g ≤ e := by |
| have hh : physicalDist f g^2 ≤ e^2 := by |
| rw [physicalDist_sq,physicalError] |
| calc |
| _ ≤ ∫ _x : TripleTorus, e^2 ∂tripleVolume := |
| integral_mono (((hf.sub hg).norm.pow 2).integrable_of_hasCompactSupport |
| (HasCompactSupport.of_compactSpace _)) (integrable_const _) |
| (fun x => pow_le_pow_left₀ (norm_nonneg _) (h x) 2) |
| _ = _ := by simp |
| nlinarith [physicalDist_nonneg f g] |
| |
| lemma small_angular_loss {δ e t : ℝ} (hδ : 0 ≤ δ) (hd : δ < 1/2) |
| (he : 0 < e) (hem : e ≤ 1/8) (ht : 0 < t) (htm : t ≤ e^2) : |
| (1+e)^2*(2*δ+2*t) < (Real.sqrt (2*δ)+5*e)^2 := by |
| have hs : 0 ≤ Real.sqrt (2*δ) := Real.sqrt_nonneg _ |
| have hss : (Real.sqrt (2*δ))^2=2*δ := Real.sq_sqrt (by positivity) |
| have hs1 : Real.sqrt (2*δ) ≤ 1 := (Real.sqrt_le_iff).2 ⟨by norm_num,by linarith⟩ |
| have he2 : e^2 ≤ e/8 := by nlinarith |
| have hm : (1+e)*(Real.sqrt (2*δ)+2*e) < Real.sqrt (2*δ)+5*e := by |
| have hh := mul_le_mul_of_nonneg_left hs1 he.le |
| nlinarith |
| have hn : 0 ≤ (1+e)*(Real.sqrt (2*δ)+2*e) := by positivity |
| have hb : 2*δ+2*t ≤ (Real.sqrt (2*δ)+2*e)^2 := by |
| nlinarith [mul_nonneg hs he.le] |
| have hmul := mul_le_mul_of_nonneg_left hb (sq_nonneg (1+e)) |
| have hsq := sq_lt_sq₀ hn (by positivity : 0 ≤ Real.sqrt (2*δ)+5*e) |>.2 hm |
| rw [mul_pow] at hsq |
| exact hmul.trans_lt hsq |
| |
| /-- The INITIAL cutoff costs the exact old complement square root. Both slow |
| components are retained as the very same finite real tensor polynomial. -/ |
| theorem exists_initial_tensor_test {h : TripleTorus → ℂ} (hh : Continuous h) |
| (hr : ∀ x, conj (h x)=h x) (hc : ∫ x, h x ∂tripleVolume=0) (hb : ∀ x, ‖h x‖ ≤ 1) |
| {δ : ℝ} (hδ : 0 ≤ δ) (hd : δ < 1/2) |
| (V : ℝ → ℝ) (hp : Periodic V 1) (hs : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) V) |
| (hv : ∀ x ∈ Ioo δ (1-δ), 0 < deriv V x) |
| {ε : ℝ} (hε : 0 < ε) : |
| ∃ c : TensorIndex →₀ ℂ, c 0=0 ∧ (∀ k, c (-k)=conj (c k)) ∧ |
| ∃ H : RealPacketFamily, H.data.V=V ∧ H.data.GoodArc δ ∧ |
| physicalDist h (fun x => H.vector x+tensorPolynomial (tensorMiddle c) x+tensorPolynomial (tensorLast c) x) |
| < Real.sqrt (2*δ)+ε := by |
| classical |
| let e := min (ε/8) (1/8) |
| have he : 0 < e := lt_min (by positivity) (by norm_num) |
| have hem : e ≤ 1/8 := min_le_right _ _ |
| have heε : 8*e ≤ ε := by have := min_le_left (ε/8) (1/8); dsimp [e]; linarith |
| obtain ⟨c,hc0,hcr,hce⟩ := exists_real_centered_tensor hh hr hc he |
| let t := min (e^2) ((1/2-δ)/2) |
| have ht : 0 < t := lt_min (sq_pos_of_pos he) (by linarith) |
| have hdt : δ+t < 1/2 := by have := min_le_right (e^2) ((1/2-δ)/2); dsimp [t]; linarith |
| obtain ⟨χ,hχs,hχc,hχI,hχb,_hχ1,hχe⟩ := exists_sharp_arc_cutoff hδ ht hdt |
| obtain ⟨P,hPV,hPg,hPr,_hPm,hPv⟩ := exists_rotated_tensor_packets (tensorAngular c) |
| (tensorAngular_reflection hcr) 0 1 2 (fun _ => tensorAngular_nonzero) |
| hχs hχc hδ hd hχI V hp hs hv |
| let H : RealPacketFamily := ⟨_,inferInstance,P,tensorSupportNeg (tensorAngular_reflection hcr), |
| tensorSupportNeg_involutive _,hPr⟩ |
| refine ⟨c,hc0,hcr,H,hPV,hPg,?_⟩ |
| have hχsupp : support χ ⊆ Ioo (0:ℝ) 1 := fun x hx => by |
| have hx := hχI (subset_tsupport _ hx) |
| exact ⟨hδ.trans_lt hx.1,by linarith [hx.2]⟩ |
| have hχcont : Continuous ((periodize_periodic χ).lift) := |
| continuous_of_continuous_lift (by simpa only [Periodic.lift_coe] using (contDiff_periodize hχs hχc).continuous) |
| have hHv : H.vector = fun x => ((periodize_periodic χ).lift x.2.1:ℂ)*tensorPolynomial (tensorAngular c) x := by |
| funext x |
| exact hPv x |
| have hcb (x : TripleTorus) : ‖tensorPolynomial c x‖ ≤ 1+e := by |
| have ht := norm_le_norm_add_norm_sub (h x) (tensorPolynomial c x) |
| linarith [hb x,hce x] |
| have hA : physicalDist (tensorPolynomial (tensorAngular c)) H.vector < Real.sqrt (2*δ)+5*e := by |
| apply (physicalDist_lt_iff _ _ (by positivity)).2 |
| rw [hHv] |
| have htE := tensorAngular_cutoff_energy c (by positivity : 0 ≤ 1+e) hcb hχcont |
| have hl := circle_cutoff_squared_error hχc hχsupp hχb |
| rw [hl] at htE |
| exact htE.trans_lt ((mul_le_mul_of_nonneg_left hχe (sq_nonneg (1+e))).trans_lt |
| (small_angular_loss hδ hd he hem ht (min_le_left _ _))) |
| have hpoly : physicalDist h (tensorPolynomial c) ≤ e := physicalDist_le_of_uniform hh |
| (tensorPolynomial_continuous c) he.le (fun x => (hce x).le) |
| let K := fun x => H.vector x+tensorPolynomial (tensorMiddle c) x+tensorPolynomial (tensorLast c) x |
| have hKc : Continuous K := (H.continuous_vector.add (tensorPolynomial_continuous _)).add (tensorPolynomial_continuous _) |
| have hAK : physicalDist (tensorPolynomial c) K = physicalDist (tensorPolynomial (tensorAngular c)) H.vector := by |
| have hcFun := funext (tensor_split_vector c) |
| rw [hcFun] |
| change physicalDist (fun x => (tensorPolynomial (tensorAngular c) x+tensorPolynomial (tensorMiddle c) x)+tensorPolynomial (tensorLast c) x) |
| (fun x => (H.vector x+tensorPolynomial (tensorMiddle c) x)+tensorPolynomial (tensorLast c) x) = _ |
| rw [physicalDist_add_right,physicalDist_add_right] |
| have hsum := physicalDist_triangle (continuous_triple_memLp hh) (continuous_triple_memLp (tensorPolynomial_continuous c)) |
| (continuous_triple_memLp hKc) |
| rw [hAK] at hsum |
| have hh' := hsum.trans_lt (add_lt_add_of_le_of_lt hpoly hA) |
| exact hh'.trans_le (by dsimp [e] at *; linarith) |
| end ThreeTorus |
| end |
| end |
| |
| end OAI |
| |
