Download data/lean/OAI/Dynamics/ThreeTorus/NeutralSupport.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 33.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/ThreeTorus/NeutralSupport.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Dynamics/ThreeTorus/NeutralSupport.lean
-
curl -L -o NeutralSupport.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/ThreeTorus/NeutralSupport.lean
33.7 kB
| import OAI.Dynamics.ThreeTorus.Transmission | |
| namespace OAI | |
| /-! Neutral lattice sampling, retained support, and stationary image separation. -/ | |
| section | |
| noncomputable section | |
| open MeasureTheory Set Filter | |
| open scoped Topology | |
| namespace ThreeTorus | |
| lemma cell_sample_error {f : β β β} (hf : ContDiff β 1 f) (a : β) : | |
| |f a - β« x in a..a+1, f x| β€ β« x in a..a+1, |deriv f x| := by | |
| have hc : Continuous (fun x => |deriv f x|) := (hf.continuous_deriv (by norm_num)).abs | |
| have hbound (x : β) (hx : x β Icc a (a+1)) : | |
| |f a-f x| β€ β« t in a..a+1, |deriv f t| := by | |
| have hFTC := intervalIntegral.integral_deriv_eq_sub | |
| (fun t _ => hf.differentiable (by norm_num) t) | |
| ((hf.continuous_deriv (by norm_num)).intervalIntegrable (a := a) (b := x)) | |
| calc | |
| _ = |β« t in a..x, deriv f t| := by rw [hFTC, abs_sub_comm] | |
| _ β€ β« t in a..x, |deriv f t| := by | |
| simpa only [Real.norm_eq_abs] using intervalIntegral.norm_integral_le_integral_norm hx.1 (f := deriv f) | |
| _ β€ β« t in a..a+1, |deriv f t| := by | |
| exact intervalIntegral.integral_mono_interval le_rfl hx.1 hx.2 | |
| (Filter.Eventually.of_forall (fun _ => abs_nonneg _)) (hc.intervalIntegrable _ _) | |
| calc | |
| _ = |β« x in a..a+1, (f a-f x)| := by | |
| rw [intervalIntegral.integral_sub intervalIntegrable_const (hf.continuous.intervalIntegrable _ _)] | |
| simp | |
| _ β€ β« x in a..a+1, |f a-f x| := by | |
| simpa only [Real.norm_eq_abs] using intervalIntegral.norm_integral_le_integral_norm (by linarith : a β€ a+1) | |
| (f := fun x => f a-f x) | |
| _ β€ β« _ in a..a+1, (β« t in a..a+1, |deriv f t|) := | |
| intervalIntegral.integral_mono_on (by linarith) ((continuous_const.sub hf.continuous).abs.intervalIntegrable _ _) | |
| intervalIntegrable_const hbound | |
| _ = _ := by simp | |
| /-- Arbitrary-offset unit lattice estimate, before scaling to the neutral refresh mesh. -/ | |
| lemma lattice_sample_error {f : β β β} (hf : ContDiff β 1 f) | |
| (hi : Integrable f) (hdi : Integrable (fun x => |deriv f x|)) (a : β) : | |
| Summable (fun j : β€ => f (a+j)) β§ | |
| |(β' j : β€, f (a+j)) - β« x, f x| β€ β« x, |deriv f x| := by | |
| let c (j : β€) := β« x in (a+j)..(a+j+1), f x | |
| let b (j : β€) := β« x in (a+j)..(a+j+1), |deriv f x| | |
| let e (j : β€) := f (a+j)-c j | |
| have hc : HasSum c (β« x, f x) := hi.hasSum_intervalIntegral a | |
| have hb : HasSum b (β« x, |deriv f x|) := hdi.hasSum_intervalIntegral a | |
| have heB (j : β€) : βe jβ β€ b j := by | |
| exact cell_sample_error hf (a+j) | |
| have he : Summable e := hb.summable.of_norm_bounded heB | |
| have hid (j : β€) : e j+c j = f (a+j) := by dsimp [e,c]; ring | |
| have hsum : HasSum (fun j : β€ => f (a+j)) ((β' j, e j)+(β« x, f x)) := | |
| (he.hasSum.add hc).congr_fun (fun j => (hid j).symm) | |
| refine β¨hsum.summable, ?_β© | |
| rw [hsum.tsum_eq, add_sub_cancel_right] | |
| calc | |
| _ β€ β' j, βe jβ := by simpa only [Real.norm_eq_abs] using norm_tsum_le_tsum_norm he.norm | |
| _ β€ β' j, b j := he.norm.tsum_le_tsum heB hb.summable | |
| _ = _ := hb.tsum_eq | |
| /-- The mesh version of the arbitrary-offset Riemann estimate in neutral refresh. -/ | |
| lemma mesh_sample_error {f : β β β} (hf : ContDiff β 1 f) | |
| (hi : Integrable f) (hdi : Integrable (fun x => |deriv f x|)) | |
| {h : β} (hh : 0 < h) (a : β) : | |
| Summable (fun j : β€ => f (a+h*j)) β§ | |
| |h*(β' j : β€, f (a+h*j)) - β« x, f x| β€ h*β« x, |deriv f x| := by | |
| let g : β β β := fun x => f (h*x) | |
| have hg : ContDiff β 1 g := hf.comp (contDiff_const.mul contDiff_id) | |
| have hgi : Integrable g := hi.comp_mul_left' hh.ne' | |
| have hd (x : β) : deriv g x = deriv f (h*x)*h := by | |
| simpa only [g, Function.comp_def, mul_one] using (((hf.differentiable (by norm_num) (h*x)).hasDerivAt).comp x | |
| ((hasDerivAt_id x).const_mul h)).deriv | |
| have hdgi : Integrable (fun x => |deriv g x|) := by | |
| simp_rw [hd, abs_mul, abs_of_pos hh] | |
| exact (hdi.comp_mul_left' hh.ne').mul_const h | |
| have hid (j : β€) : g (a/h+j) = f (a+h*j) := by | |
| dsimp [g]; congr 1; field_simp | |
| obtain β¨hs,hbβ© := lattice_sample_error hg hgi hdgi (a/h) | |
| simp_rw [hid] at hs hb | |
| refine β¨hs, ?_β© | |
| have hgint : (β« x, g x) = hβ»ΒΉ*(β« x, f x) := by | |
| exact (Measure.integral_comp_mul_left f h).trans (by rw [abs_of_pos (inv_pos.mpr hh)]; rfl) | |
| have hdint : (β« x, |deriv g x|) = β« x, |deriv f x| := by | |
| simp_rw [hd, abs_mul, abs_of_pos hh] | |
| rw [integral_mul_const, Measure.integral_comp_mul_left (fun x => |deriv f x|) h] | |
| rw [abs_of_pos (inv_pos.mpr hh)] | |
| simp only [smul_eq_mul] | |
| field_simp | |
| rw [hgint, hdint] at hb | |
| calc | |
| _ = |h*((β' j : β€, f (a+h*j)) - hβ»ΒΉ*(β« x, f x))| := by | |
| congr 1 | |
| rw [mul_sub, β mul_assoc, mul_inv_cancelβ hh.ne', one_mul] | |
| _ = h*|(β' j : β€, f (a+h*j)) - hβ»ΒΉ*(β« x, f x)| := by | |
| rw [abs_mul, abs_of_pos hh] | |
| _ β€ _ := mul_le_mul_of_nonneg_left hb hh.le | |
| /-- Exact normalization for a residue class of the neutral refresh lattice. -/ | |
| lemma neutral_residue_riemann_error {f : β β β} (hf : ContDiff β 1 f) | |
| (hi : Integrable f) (hdi : Integrable (fun x => |deriv f x|)) | |
| {P s L : β} (hP : 0 < P) (hs : 0 < s) (hL : 0 < L) (a : β) : | |
| |(s*L)β»ΒΉ*(β' j : β€, f (a+P/(s*L)*j)) - Pβ»ΒΉ*(β« x, f x)| | |
| β€ (s*L)β»ΒΉ*(β« x, |deriv f x|) := by | |
| have hh : 0 < P/(s*L) := by positivity | |
| have hb := (mesh_sample_error hf hi hdi hh a).2 | |
| calc | |
| _ = |Pβ»ΒΉ*((P/(s*L))*(β' j : β€, f (a+P/(s*L)*j)) - β« x, f x)| := by | |
| congr 1 | |
| field_simp | |
| _ = Pβ»ΒΉ*|(P/(s*L))*(β' j : β€, f (a+P/(s*L)*j)) - β« x, f x| := by | |
| rw [abs_mul, abs_of_pos (inv_pos.mpr hP)] | |
| _ β€ Pβ»ΒΉ*((P/(s*L))*(β« x, |deriv f x|)) := | |
| mul_le_mul_of_nonneg_left hb (by positivity) | |
| _ = _ := by field_simp | |
| end ThreeTorus | |
| namespace ThreeTorus | |
| open MeasureTheory Set Function Filter | |
| open scoped Topology NNReal | |
| /-- Mesh reversal uses the actual integer negation bijection; negative old | |
| angular indices have the same arbitrary-offset Riemann estimate. -/ | |
| lemma signed_mesh_sample_error {f : β β β} (hf : ContDiff β 1 f) | |
| (hi : Integrable f) (hdi : Integrable (fun x => |deriv f x|)) | |
| {h : β} (hh : h β 0) (a : β) : | |
| Summable (fun j : β€ => f (a+h*j)) β§ | |
| |(|h| *(β' j : β€, f (a+h*j))) - β« x, f x| β€ |h| *β« x, |deriv f x| := by | |
| rcases lt_or_gt_of_ne hh with hh | hh | |
| Β· obtain β¨hs,hbβ© := mesh_sample_error hf hi hdi (h := -h) (by linarith) a | |
| have he (j : β€) : f (a+h*j) = f (a+(-h)*(-j:β€)) := by | |
| push_cast; congr 1; ring | |
| have ht : (β' j : β€, f (a+h*j)) = β' j : β€, f (a+(-h)*j) := by | |
| simp_rw [he] | |
| exact (Equiv.neg β€).tsum_eq (fun j : β€ => f (a+(-h)*j)) | |
| refine β¨?_,?_β© | |
| Β· simpa only [Function.comp_def, he] using hs.comp_injective (neg_injective : Injective (Neg.neg : β€ β β€)) | |
| Β· rw [abs_of_neg hh,ht] | |
| exact hb | |
| Β· simpa only [abs_of_pos hh] using mesh_sample_error hf hi hdi hh a | |
| /-- Exact signed normalization, with arbitrary offset and arbitrary positive | |
| integer residue spacing. This is source (neutral-riemann-error). -/ | |
| lemma signed_neutral_residue_error {f : β β β} (hf : ContDiff β 1 f) | |
| (hi : Integrable f) (hdi : Integrable (fun x => |deriv f x|)) | |
| {P s L : β} (hP : 0 < P) (hs : s β 0) (hL : 0 < L) (y Ξ² : β) : | |
| Summable (fun j : β€ => (|s| *L)β»ΒΉ*f (((y+j*P)/s-Ξ²)/L)) β§ | |
| |(β' j : β€, (|s| *L)β»ΒΉ*f (((y+j*P)/s-Ξ²)/L))- | |
| Pβ»ΒΉ*(β« a, f a)| β€ (|s| *L)β»ΒΉ*(β« a, |deriv f a|) := by | |
| have hh : P/(s*L) β 0 := div_ne_zero hP.ne' (mul_ne_zero hs hL.ne') | |
| obtain β¨hsum,hbβ© := signed_mesh_sample_error hf hi hdi hh ((y/s-Ξ²)/L) | |
| have hi' (j : β€) : (y/s-Ξ²)/L+(P/(s*L))*j = ((y+j*P)/s-Ξ²)/L := by ring | |
| simp_rw [hi'] at hsum hb | |
| have hab : |P/(s*L)| = P/(|s| *L) := by rw [abs_div,abs_mul,abs_of_pos hP,abs_of_pos hL] | |
| rw [hab] at hb | |
| refine β¨hsum.mul_left _,?_β© | |
| rw [tsum_mul_left] | |
| calc | |
| _ = |Pβ»ΒΉ*((P/(|s| *L))*(β' j : β€, f (((y+j*P)/s-Ξ²)/L)) - β« a, f a)| := by | |
| generalize (β' j : β€, f (((y+j*P)/s-Ξ²)/L)) = S | |
| congr 1; field_simp | |
| _ = Pβ»ΒΉ*|(P/(|s| *L))*(β' j : β€, f (((y+j*P)/s-Ξ²)/L)) - β« a, f a| := by | |
| rw [abs_mul,abs_of_pos (inv_pos.mpr hP)] | |
| _ β€ Pβ»ΒΉ*((P/(|s| *L))*(β« a, |deriv f a|)) := | |
| mul_le_mul_of_nonneg_left hb (by positivity) | |
| _ = _ := by field_simp | |
| lemma fine_affine_neutral_error {F : β Γ β β β} {P n : β} {h : β€} {L s : β} | |
| (hP : 0 < P) (hs : s β 0) (hL : 0 < L) (Ξ² : β) | |
| (hF : ContDiff β 1 (fun a => F (s,a))) | |
| (hi : Integrable (fun a => F (s,a))) | |
| (hd : Integrable (fun a => |deriv (fun a => F (s,a)) a|)) : | |
| |fineResidueKernel (affineKernel F L Ξ²) P h n s- | |
| (P:β)β»ΒΉ*(β« a, F (s,a))| β€ | |
| (|s| *L)β»ΒΉ*(β« a, |deriv (fun a => F (s,a)) a|) := by | |
| have hh := (signed_neutral_residue_error (P := (P:β)) hF hi hd (by exact_mod_cast hP) hs hL | |
| ((n:β)*s-h) Ξ²).2 | |
| have he : fineResidueKernel (affineKernel F L Ξ²) P h n s = | |
| β' j : β€, (|s| *L)β»ΒΉ*F (s,((((n:β)*s-h)+j*P)/s-Ξ²)/L) := by | |
| unfold fineResidueKernel affineKernel | |
| have ht := (Equiv.neg β€).tsum_eq | |
| (fun j : β€ => (|s| *L)β»ΒΉ*F (s,((((n:β)*s-h)+j*P)/s-Ξ²)/L)) | |
| convert ht using 1 | |
| apply tsum_congr | |
| intro j | |
| simp only [Equiv.neg_apply,Int.cast_neg] | |
| congr 3; ring | |
| rw [he] | |
| exact hh | |
| end ThreeTorus | |
| namespace ThreeTorus | |
| open MeasureTheory Set Function Filter | |
| open scoped Topology NNReal | |
| lemma compact_slice_tsupport {F : β Γ β β β} {D : β} | |
| (hFa : β s a, D < |a| β F (s,a) = 0) (s : β) : | |
| tsupport (fun a => F (s,a)) β Icc (-D) D := by | |
| apply closure_minimal _ isClosed_Icc | |
| intro a ha | |
| by_contra hn | |
| exact ha (hFa s a (lt_of_not_ge (by simpa only [mem_Icc,β abs_le] using hn))) | |
| lemma compact_slice_support {F : β Γ β β β} {D : β} | |
| (hFa : β s a, D < |a| β F (s,a) = 0) (s : β) : | |
| HasCompactSupport (fun a => F (s,a)) := | |
| isCompact_Icc.of_isClosed_subset isClosed_closure (compact_slice_tsupport hFa s) | |
| lemma compact_slice_derivative_bound {F : β Γ β β β} {D : β} {C : ββ₯0} | |
| (hF : ContDiff β ((β€ : ββ) : WithTop ββ) F) | |
| (hFa : β s a, D < |a| β F (s,a) = 0) (hD : 0 β€ D) | |
| (hC : LipschitzWith C F) (s : β) : | |
| Integrable (fun a => F (s,a)) β§ | |
| Integrable (fun a => |deriv (fun a => F (s,a)) a|) β§ | |
| (β« a, |deriv (fun a => F (s,a)) a|) β€ 2*D*C := by | |
| have hf : ContDiff β ((β€ : ββ) : WithTop ββ) (fun a => F (s,a)) := | |
| hF.comp ((contDiff_const (c := s)).prodMk contDiff_id) | |
| have hc := compact_slice_support hFa s | |
| have hfd : Continuous (deriv (fun a => F (s,a))) := hf.continuous_deriv (by simp) | |
| have hdi : Integrable (fun a => |deriv (fun a => F (s,a)) a|) := | |
| hfd.abs.integrable_of_hasCompactSupport (hc.deriv.comp_left (abs_zero)) | |
| have hl : LipschitzWith C (fun a => F (s,a)) := by | |
| apply LipschitzWith.of_dist_le_mul | |
| intro a b | |
| simpa only [Prod.dist_eq,dist_self,max_eq_right dist_nonneg] using hC.dist_le_mul (s,a) (s,b) | |
| refine β¨hf.continuous.integrable_of_hasCompactSupport hc,hdi,?_β© | |
| have hzero (a : β) (ha : a β Icc (-D) D) : deriv (fun a => F (s,a)) a = 0 := by | |
| by_contra hn | |
| exact ha (compact_slice_tsupport hFa s (support_deriv_subset hn)) | |
| rw [β setIntegral_eq_integral_of_forall_compl_eq_zero (s := Icc (-D) D) | |
| (f := fun a => |deriv (fun a => F (s,a)) a|) (fun a ha => by rw [hzero a ha,abs_zero])] | |
| calc | |
| _ β€ β« _ in Icc (-D) D, (C:β) := | |
| setIntegral_mono_on hdi.integrableOn (integrableOn_const (by simp)) measurableSet_Icc | |
| (fun a _ => by simpa only [β Real.norm_eq_abs] using norm_deriv_le_of_lipschitz (xβ := a) hl) | |
| _ = _ := by | |
| rw [setIntegral_const,Real.volume_real_Icc_of_le (by linarith : -D β€ D)] | |
| simp only [smul_eq_mul] | |
| ring | |
| lemma compact_slice_integral_continuous {F : β Γ β β β} {D : β} | |
| (hF : Continuous F) (hFa : β s a, D < |a| β F (s,a) = 0) : | |
| Continuous (fun s => β« a, F (s,a)) := by | |
| apply continuousOn_univ.mp | |
| apply continuousOn_integral_of_compact_support (k := Icc (-D) D) isCompact_Icc | |
| Β· exact hF.continuousOn | |
| Β· intro s a _ ha | |
| exact hFa s a (lt_of_not_ge (by simpa only [mem_Icc,β abs_le] using ha)) | |
| lemma fine_affine_neutral_uniform {F : β Γ β β β} {P n : β} {h : β€} | |
| {D Ξ΅ L : β} {C : ββ₯0} | |
| (hF : ContDiff β ((β€ : ββ) : WithTop ββ) F) | |
| (hFa : β s a, D < |a| β F (s,a) = 0) (hD : 0 β€ D) | |
| (hC : LipschitzWith C F) (hΞ΅ : 0 < Ξ΅) | |
| (hz : β s a, |s| < Ξ΅ β F (s,a) = 0) | |
| (hP : 0 < P) (hL : 0 < L) (Ξ² s : β) : | |
| |fineResidueKernel (affineKernel F L Ξ²) P h n s- | |
| (P:β)β»ΒΉ*(β« a, F (s,a))| β€ (Ξ΅*L)β»ΒΉ*(2*D*C) := by | |
| by_cases hs : |s| < Ξ΅ | |
| Β· have he : (β« a, F (s,a)) = 0 := by simp [hz s _ hs] | |
| have hk : fineResidueKernel (affineKernel F L Ξ²) P h n s = 0 := by | |
| unfold fineResidueKernel affineKernel | |
| simp [hz s _ hs] | |
| rw [hk,he,mul_zero,sub_self,abs_zero] | |
| positivity | |
| Β· have hsΞ΅ : Ξ΅ β€ |s| := le_of_not_gt hs | |
| have hs0 : s β 0 := by intro hh; simp [hh] at hsΞ΅; linarith | |
| obtain β¨hi,hd,hbβ© := compact_slice_derivative_bound hF hFa hD hC s | |
| calc | |
| _ β€ (|s| *L)β»ΒΉ*(β« a, |deriv (fun a => F (s,a)) a|) := | |
| fine_affine_neutral_error hP hs0 hL Ξ² | |
| ((hF.comp (contDiff_const.prodMk contDiff_id)).of_le (by simp)) hi hd | |
| _ β€ (|s| *L)β»ΒΉ*(2*D*C) := mul_le_mul_of_nonneg_left hb (by positivity) | |
| _ β€ _ := mul_le_mul_of_nonneg_right | |
| (inv_antiβ (by positivity) (mul_le_mul_of_nonneg_right hsΞ΅ hL.le)) (by positivity) | |
| end ThreeTorus | |
| namespace ThreeTorus | |
| open MeasureTheory Set Function Filter | |
| open scoped Topology NNReal | |
| lemma fine_affine_neutral_l1_error {F : β Γ β β β} {P n : β} {h : β€} | |
| {A D Ξ΅ L : β} {C : ββ₯0} | |
| (hF : ContDiff β ((β€ : ββ) : WithTop ββ) F) | |
| (hFs : β s a, A < |s| β F (s,a) = 0) (hA : 0 β€ A) | |
| (hFa : β s a, D < |a| β F (s,a) = 0) (hD : 0 β€ D) | |
| (hC : LipschitzWith C F) (hΞ΅ : 0 < Ξ΅) | |
| (hz : β s a, |s| < Ξ΅ β F (s,a) = 0) | |
| (hn : 0 < n) (hP : 0 < P) (hL : 0 < L) (Ξ² : β) : | |
| (β« s, |fineResidueKernel (affineKernel F L Ξ²) P h n s- | |
| (P:β)β»ΒΉ*(β« a, F (s,a))|) β€ (2*A)*((Ξ΅*L)β»ΒΉ*(2*D*C)) := by | |
| obtain β¨M,hMβ© := exists_nat_ge (A*(L*D+|Ξ²|)) | |
| have hk := fineResidueKernel_regular (h := h) (n := n) | |
| (affineKernel_smooth (L := L) (Ξ² := Ξ²) hF hΞ΅ hz).continuous | |
| (show 0 < max A 1 from lt_max_of_lt_right zero_lt_one) | |
| (fun s y hh => affineKernel_eq_zero_s hFs (lt_of_le_of_lt (le_max_left _ _) hh)) | |
| (fun s y hh => affineKernel_eq_zero_y hL hA hD hFs hFa (lt_of_le_of_lt hM hh)) hn hP | |
| have hZ := compact_slice_integral_continuous hF.continuous hFa | |
| have hcZ : HasCompactSupport (fun s => β« a, F (s,a)) := by | |
| apply HasCompactSupport.intro (isCompact_Icc (a := -A) (b := A)) | |
| intro s hs | |
| have hab : A < |s| := lt_of_not_ge (by simpa only [mem_Icc,β abs_le] using hs) | |
| simp [hFs s _ hab] | |
| have hi := (hk.2.sub ((hZ.integrable_of_hasCompactSupport hcZ).const_mul (P:β)β»ΒΉ)).abs | |
| have hzero (s : β) (hs : s β Icc (-A) A) : | |
| |fineResidueKernel (affineKernel F L Ξ²) P h n s-(P:β)β»ΒΉ*(β« a, F (s,a))| = 0 := by | |
| have hab : A < |s| := lt_of_not_ge (by simpa only [mem_Icc,β abs_le] using hs) | |
| rw [fineResidueKernel_eq_zero (fun s y hh => affineKernel_eq_zero_s hFs hh) hab] | |
| simp [hFs s _ hab] | |
| rw [β setIntegral_eq_integral_of_forall_compl_eq_zero (s := Icc (-A) A) hzero] | |
| calc | |
| _ β€ β« _ in Icc (-A) A, (Ξ΅*L)β»ΒΉ*(2*D*C) := | |
| setIntegral_mono_on hi.integrableOn (integrableOn_const (by simp)) measurableSet_Icc | |
| (fun s _ => fine_affine_neutral_uniform hF hFa hD hC hΞ΅ hz hP hL Ξ² s) | |
| _ = _ := by | |
| rw [setIntegral_const,Real.volume_real_Icc_of_le (by linarith : -A β€ A)] | |
| simp only [smul_eq_mul] | |
| ring | |
| lemma compact_rect_bounds {F : β Γ β β β} (hc : HasCompactSupport F) : | |
| β A D : β, 0 β€ A β§ 0 β€ D β§ | |
| (β s a, A < |s| β F (s,a) = 0) β§ (β s a, D < |a| β F (s,a) = 0) := by | |
| obtain β¨R,hRβ© := hc.isBounded.subset_closedBall (0 : β Γ β) | |
| refine β¨max R 0,max R 0,le_max_right _ _,le_max_right _ _,?_,?_β© | |
| Β· intro s a hs | |
| by_contra hn | |
| have hh := hR (subset_tsupport _ hn) | |
| rw [Metric.mem_closedBall,dist_zero_right,Prod.norm_def] at hh | |
| have hh' : |s| β€ R := by simpa only [Real.norm_eq_abs] using (le_max_left βsβ βaβ).trans hh | |
| exact (not_lt_of_ge (hh'.trans (le_max_left _ _))) hs | |
| Β· intro s a hs | |
| by_contra hn | |
| have hh := hR (subset_tsupport _ hn) | |
| rw [Metric.mem_closedBall,dist_zero_right,Prod.norm_def] at hh | |
| have hh' : |a| β€ R := by simpa only [Real.norm_eq_abs] using (le_max_right βsβ βaβ).trans hh | |
| exact (not_lt_of_ge (hh'.trans (le_max_left _ _))) hs | |
| /-- Uniform residue equalization for actual compact smooth stationary weight. | |
| One slope is chosen before the passage integer, with all lattice phases, | |
| all residues, and both signs controlled. -/ | |
| lemma neutral_fine_l1_bound {F : β Γ β β β} | |
| (hF : ContDiff β ((β€ : ββ) : WithTop ββ) F) (hcF : HasCompactSupport F) | |
| {Ξ΅ : β} (hΞ΅ : 0 < Ξ΅) (hz : β s a, |s| < Ξ΅ β F (s,a) = 0) : | |
| β C : β, 0 β€ C β§ β {P n : β}, 0 < P β 0 < n β β h : β€, β L : β, 0 < L β β Ξ² : β, | |
| (β« s, |fineResidueKernel (affineKernel F L Ξ²) P h n s- | |
| (P:β)β»ΒΉ*(β« a, F (s,a))|) β€ C/L := by | |
| obtain β¨A,D,hA,hD,hFs,hFaβ© := compact_rect_bounds hcF | |
| obtain β¨C,hCβ© := compact_smooth_lipschitz hF hcF | |
| refine β¨(2*A)*(2*D*C)/Ξ΅,by positivity,?_β© | |
| intro P n hP hn h L hL Ξ² | |
| have hb := fine_affine_neutral_l1_error (h := h) hF hFs hA hFa hD hC hΞ΅ hz hn hP hL Ξ² | |
| convert hb using 1; ring | |
| end ThreeTorus | |
| namespace ThreeTorus | |
| open MeasureTheory Set Function Filter | |
| open scoped Topology NNReal | |
| lemma deriv_affine_on {I : Set β} {J : β β β} {L Ξ² : β} | |
| (hIo : IsOpen I) (he : β a β I, J a = L*a+Ξ²) {a : β} (ha : a β I) : | |
| deriv J a = L := by | |
| have hev : J =αΆ [π a] (fun x => L*x+Ξ²) := by | |
| filter_upwards [hIo.mem_nhds ha] with x hx using he x hx | |
| rw [hev.deriv_eq] | |
| simp | |
| /-- The branch is the actual inverse of the affine jitter on the good arc. | |
| Off that image both sides vanish because the old stationary weight is cut off. -/ | |
| lemma branchKernel_affine_on {I : Set β} {J : β β β} {F : β Γ β β β} {L Ξ² : β} | |
| (hIo : IsOpen I) (hL : 0 < L) (he : β a β I, J a = L*a+Ξ²) | |
| (hs : tsupport F β I ΓΛ’ univ) (y s : β) : | |
| branchKernel I J F (y,s) = Lβ»ΒΉ*F ((y-Ξ²)/L,s) := by | |
| classical | |
| have hinj : InjOn J I := by | |
| intro a ha b hb hab | |
| rw [he a ha,he b hb] at hab | |
| nlinarith | |
| by_cases hy : y β J '' I | |
| Β· obtain β¨a,ha,rflβ© := hy | |
| have hg := hinj.leftInvOn_invFunOn ha | |
| have ht : (J a-Ξ²)/L = a := by rw [he a ha]; field_simp; ring | |
| rw [branchKernel,ite_eq_left (mem_image_of_mem J ha),hg,deriv_affine_on hIo he ha, | |
| abs_of_pos hL,ht] | |
| ring | |
| Β· have ha : (y-Ξ²)/L β I := by | |
| intro hh | |
| apply hy | |
| refine β¨(y-Ξ²)/L,hh,?_β© | |
| rw [he _ hh] | |
| field_simp | |
| ring | |
| have hz : F ((y-Ξ²)/L,s) = 0 := by | |
| by_contra hn | |
| exact ha (hs (subset_tsupport _ hn)).1 | |
| rw [branchKernel,ite_eq_right hy,hz,mul_zero] | |
| lemma passageBranchKernel_affine_on {I : Set β} {J : β β β} {F : β Γ β β β} {L Ξ² : β} | |
| (hIo : IsOpen I) (hL : 0 < L) (he : β a β I, J a = L*a+Ξ²) | |
| (hs : tsupport F β I ΓΛ’ univ) : | |
| passageBranchKernel I J F = affineKernel (F β Prod.swap) L Ξ² := by | |
| funext s y | |
| rw [passageBranchKernel_formula,branchKernel_affine_on hIo hL he hs] | |
| simp only [affineKernel,Function.comp_apply,Prod.swap_prod_mk,mul_inv_rev] | |
| ring | |
| lemma compact_slice_integral_regular {F : β Γ β β β} | |
| (hF : Continuous F) (hcF : HasCompactSupport F) : | |
| Continuous (fun s => β« a, F (s,a)) β§ Integrable (fun s => β« a, F (s,a)) := by | |
| obtain β¨A,D,_,_,hFs,hFaβ© := compact_rect_bounds hcF | |
| have hZ := compact_slice_integral_continuous hF hFa | |
| refine β¨hZ,hZ.integrable_of_hasCompactSupport ?_β© | |
| apply HasCompactSupport.intro (isCompact_Icc (a := -A) (b := A)) | |
| intro s hs | |
| have hab : A < |s| := lt_of_not_ge (by simpa only [mem_Icc,β abs_le] using hs) | |
| simp [hFs s _ hab] | |
| lemma affine_fine_regular {F : β Γ β β β} | |
| (hF : ContDiff β ((β€ : ββ) : WithTop ββ) F) (hcF : HasCompactSupport F) | |
| {Ξ΅ : β} (hΞ΅ : 0 < Ξ΅) (hz : β s a, |s| < Ξ΅ β F (s,a) = 0) | |
| {P n : β} (hP : 0 < P) (hn : 0 < n) (h : β€) {L : β} (hL : 0 < L) (Ξ² : β) : | |
| Continuous (fineResidueKernel (affineKernel F L Ξ²) P h n) β§ | |
| Integrable (fineResidueKernel (affineKernel F L Ξ²) P h n) := by | |
| obtain β¨A,D,hA,hD,hFs,hFaβ© := compact_rect_bounds hcF | |
| obtain β¨M,hMβ© := exists_nat_ge (A*(L*D+|Ξ²|)) | |
| apply fineResidueKernel_regular | |
| (affineKernel_smooth (L := L) (Ξ² := Ξ²) hF hΞ΅ hz).continuous | |
| (show 0 < max A 1 from lt_max_of_lt_right zero_lt_one) | |
| (fun s y hh => affineKernel_eq_zero_s hFs (lt_of_le_of_lt (le_max_left _ _) hh)) | |
| (fun s y hh => affineKernel_eq_zero_y hL hA hD hFs hFa (lt_of_le_of_lt hM hh)) hn hP | |
| /-- The neutral equalization estimate on the actual temporal circle, uniformly | |
| in the large preparation integer, residues, offsets and affine good-arc jitter. | |
| The constant is fixed using only the old cut-off stationary weight. -/ | |
| lemma neutral_branch_circle_l1_bound {F : β Γ β β β} | |
| (hF : ContDiff β ((β€ : ββ) : WithTop ββ) F) (hcF : HasCompactSupport F) | |
| {Ξ΅ : β} (hΞ΅ : 0 < Ξ΅) (hz : β a s, |s| < Ξ΅ β F (a,s) = 0) : | |
| β C : β, 0 β€ C β§ β {I : Set β} {J : β β β} {P n : β}, | |
| IsOpen I β tsupport F β I ΓΛ’ univ β 0 < P β 0 < n β | |
| β h : β€, β L : β, 0 < L β β Ξ² : β, (β a β I, J a = L*a+Ξ²) β | |
| (β« z, |foldCircleDensity (fineResidueKernel (passageBranchKernel I J F) P h n) z- | |
| foldCircleDensity (fun s => (P:β)β»ΒΉ*(β« a, F (a,s))) z| βAddCircle.haarAddCircle) β€ C/L := by | |
| have hf : ContDiff β ((β€ : ββ) : WithTop ββ) (F β Prod.swap) := | |
| hF.comp (contDiff_snd.prodMk contDiff_fst) | |
| have hc : HasCompactSupport (F β Prod.swap) := hcF.comp_homeomorph (Homeomorph.prodComm β β) | |
| have hzf : β s a, |s| < Ξ΅ β (F β Prod.swap) (s,a) = 0 := fun s a hs => hz a s hs | |
| obtain β¨C,hC,hbβ© := neutral_fine_l1_bound hf hc hΞ΅ hzf | |
| refine β¨C,hC,?_β© | |
| intro I J P n hIo hsF hP hn h L hL Ξ² he | |
| rw [passageBranchKernel_affine_on hIo hL he hsF] | |
| have hq := affine_fine_regular hf hc hΞ΅ hzf hP hn h hL Ξ² | |
| have hr := compact_slice_integral_regular hf.continuous hc | |
| calc | |
| _ β€ β« s, |fineResidueKernel (affineKernel (F β Prod.swap) L Ξ²) P h n s- | |
| (P:β)β»ΒΉ*(β« a, F (a,s))| := | |
| foldCircleDensity_l1_difference hq.1.measurable hq.2 | |
| (measurable_const.mul hr.1.measurable) (hr.2.const_mul _) | |
| _ β€ _ := hb hP hn h L hL Ξ² | |
| end ThreeTorus | |
| namespace ThreeTorus | |
| open MeasureTheory Set Function Filter | |
| open scoped Topology NNReal | |
| /-- The broad slope is chosen after the cutoff weight and before the periodic jitter is fixed; | |
| the final passage integer is only subject to a lower bound. The displayed | |
| reference density is exactly the old cutoff stationary marginal, folded to | |
| the temporal circle and divided by the residue modulus. -/ | |
| lemma exact_neutral_circle_spectral_estimate | |
| {A : UnitAddCircle Γ UnitAddCircle β β} {Aβ : UnitAddCircle β β β β} | |
| {Pr V : β β β} {m : β€} {Ξ΄ : β β β} {H : β β UnitAddCircle β UnitAddCircle} | |
| {o l u R : β} | |
| (hm : m β 0) | |
| (hH : β n (x : β), H n (x : UnitAddCircle) = ((n:β)*(Pr x+Ξ΄ n*x) : UnitAddCircle)) | |
| (hA : β a x, x β Ioc o (o+1) β A ((x : UnitAddCircle),a) = Aβ a x) | |
| (hAβ : β a, ContDiff β 2 (Aβ a)) (hAc : Continuous Aβ.uncurry) | |
| (hAd : Continuous (fun p : UnitAddCircle Γ β => deriv (Aβ p.1) p.2)) | |
| (hAr : ContDiff β ((β€ : ββ) : WithTop ββ) | |
| (fun p : β Γ β => Aβ (p.2 : UnitAddCircle) p.1)) | |
| (hsupp : β a, support (Aβ a) β Ioc l u) | |
| (hlo : o β€ l) (huo : u β€ o+1) (hlu : l β€ u) (hR : 0 < R) | |
| (hPr : ContDiff β ((β€ : ββ) : WithTop ββ) Pr) | |
| (hV : ContDiff β ((β€ : ββ) : WithTop ββ) V) (hPV : deriv Pr = V) | |
| (hdV : β x β Icc (l-2*R) (u+2*R), 0 < deriv V x) | |
| (h0 : 0 β (fun x => (m:β)*V x) '' Icc l u) | |
| (hHc : β n, Continuous (H n)) (hAcont : Continuous A) (hΞ΄t : Tendsto Ξ΄ atTop (π 0)) | |
| {I : Set β} {o' : β} | |
| {Ο : β β UnitAddCircle β β} {Ο : UnitAddCircle β β} {Οβ : β β β} | |
| (hIo : IsOpen I) | |
| (hΟβ : ContDiff β ((β€ : ββ) : WithTop ββ) Οβ) (hcΟβ : HasCompactSupport Οβ) | |
| (hsΟβ : tsupport Οβ β Ioc o' (o'+1) β© I) | |
| (heΟ : β x β Ioc o' (o'+1), Οβ x = Ο (x : UnitAddCircle)) | |
| (hΟc : Continuous Ο) (hΟc : Continuous Ο.uncurry) (hcΟ : HasCompactSupport Ο.uncurry) | |
| (hzΟ : β a, Ο 0 a = 0) | |
| (hΟ : β a, 0 β€ Ο a β§ Ο a β€ 1) (hΟ : β s a, 0 β€ Ο s a β§ Ο s a β€ 1) | |
| (hΟW : β s a, stationaryWeight (Icc (l-R) (u+R)) (fun x => (m:β)*V x) (Aβ a) s β 0 β Ο s a = 1) | |
| {Q : β} (hQ : 0 < Q) (h : β€) : | |
| let F := stationaryCutoffLift (Icc (l-R) (u+R)) (fun x => (m:β)*V x) | |
| (fun p : β Γ β => Aβ (p.2 : UnitAddCircle) p.1) Οβ | |
| β C : β, 0 β€ C β§ β L : β, 0 < L β β Ξ² : β, | |
| β (Jβ : β β β) (J : UnitAddCircle β β), | |
| (β a β I, Jβ a = L*a+Ξ²) β | |
| ContDiff β ((β€ : ββ) : WithTop ββ) Jβ β Measurable J β | |
| (β x β I, J (x : UnitAddCircle) = Jβ x) β | |
| β S : β β Finset β€, | |
| (β n, 0 < n β β k β S n, h+k*(Q:β€) β 0) β§ | |
| (β n, 0 < n β β k β S n, β a, Ο (((h+k*(Q:β€):β€):β)/n) a = 0) β§ | |
| β Ξ· : β, 0 < Ξ· β βαΆ n : β in atTop, | |
| (β« a, |foldCircleDensity (fun t => β k β S n, | |
| unfoldedModeDensity I Jβ (invFunOn Jβ I) (deriv Jβ) | |
| (circleDensityLift o' (retainedCircleWeight Ο Ο | |
| (fun n j => exactPassageCoeff m (H n) A j) n (h+k*(Q:β€)))) | |
| n ((h+k*(Q:β€):β€):β) t) a- | |
| foldCircleDensity (fun s => (Q:β)β»ΒΉ*(β« a, F (a,s))) a| | |
| βAddCircle.haarAddCircle) < C/L+Ξ· := by | |
| let B : β Γ β β β := fun p => Aβ (p.2 : UnitAddCircle) p.1 | |
| let F := stationaryCutoffLift (Icc (l-R) (u+R)) (fun x => (m:β)*V x) B Οβ | |
| change β C, _ | |
| obtain β¨hF,hcF,Ξ΅,hΞ΅,hzβ© := exact_cutoff_weight_regular hm hR hV hdV hAr | |
| (fun a => (hsupp a).trans Ioc_subset_Icc_self) hΟβ hcΟβ h0 | |
| have hKA : β p : β Γ β, B p β 0 β p.1 β Icc l u := | |
| fun p hp => Ioc_subset_Icc_self (hsupp _ hp) | |
| have hsF : tsupport F β I ΓΛ’ univ := by | |
| intro p hp | |
| exact β¨(hsΟβ (stationaryCutoffLift_support (continuous_const.mul hV.continuous) | |
| isCompact_Icc hKA hp).1).2,mem_univ _β© | |
| obtain β¨C,hC,hBoundβ© := neutral_branch_circle_l1_bound hF hcF hΞ΅ hz | |
| refine β¨C,hC,?_β© | |
| intro L hL Ξ² Jβ J he hJ hj hJe | |
| have hinj : InjOn Jβ I := by | |
| intro a ha b hb hab | |
| rw [he a ha,he b hb] at hab | |
| nlinarith | |
| have hd : β x β I, deriv Jβ x β 0 := fun x hx => by | |
| rw [deriv_affine_on hIo he hx] | |
| exact hL.ne' | |
| obtain β¨S,hSN,hST,htβ© := exact_passage_circle_spectral_limit hm hH hA hAβ hAc hAd hAr | |
| hsupp hlo huo hlu hR hPr hV hPV hdV h0 hHc hAcont hΞ΄t hJ hIo hinj hd hj hJe | |
| hΟβ hcΟβ hsΟβ heΟ hΟc hΟc hcΟ hzΟ hΟ hΟ hΟW hQ h | |
| refine β¨S,hSN,hST,?_β© | |
| intro Ξ· hΞ· | |
| have hΞ·t := ht.eventually (gt_mem_nhds hΞ·) | |
| have hu (n : β) (hn : 0 < n) : | |
| Integrable (foldCircleDensity (fun t => β k β S n, | |
| unfoldedModeDensity I Jβ (invFunOn Jβ I) (deriv Jβ) | |
| (circleDensityLift o' (retainedCircleWeight Ο Ο | |
| (fun n j => exactPassageCoeff m (H n) A j) n (h+k*(Q:β€)))) | |
| n ((h+k*(Q:β€):β€):β) t)) AddCircle.haarAddCircle := by | |
| apply integrable_foldCircleDensity | |
| Β· exact (S n).measurable_fun_sum (fun k hk => (retained_unfolded_regular hJ hIo hinj hd | |
| hΟc hΟc (fun n j => continuous_exactPassageCoeff (hHc n) hAcont j) | |
| o' hn (hSN n hn k hk)).1) | |
| Β· exact integrable_finsetSum _ (fun k hk => (retained_unfolded_regular hJ hIo hinj hd | |
| hΟc hΟc (fun n j => continuous_exactPassageCoeff (hHc n) hAcont j) | |
| o' hn (hSN n hn k hk)).2) | |
| obtain β¨hK,AK,hAK,MK,hsK,hyKβ© := passageBranchKernel_regular hJ hIo hinj hd hF hcF hsF hΞ΅ hz | |
| have hv (n : β) (hn : 0 < n) := fineResidueKernel_regular (h := h) hK hAK hsK hyK hn hQ | |
| have hw := compact_slice_integral_regular ((hF.comp (contDiff_snd.prodMk contDiff_fst)).continuous) | |
| (hcF.comp_homeomorph (Homeomorph.prodComm β β)) | |
| have hwi : Integrable (foldCircleDensity (fun s => (Q:β)β»ΒΉ*(β« a, F (a,s)))) | |
| AddCircle.haarAddCircle := | |
| integrable_foldCircleDensity (measurable_const.mul hw.1.measurable) (hw.2.const_mul _) | |
| filter_upwards [hΞ·t,eventually_gt_atTop (0 : β)] with n hn hn0 | |
| have hbn := hBound hIo hsF hQ hn0 h L hL Ξ² he | |
| exact (integral_abs_sub_triangle (hu n hn0) | |
| (integrable_foldCircleDensity (hv n hn0).1.measurable (hv n hn0).2) hwi).trans_lt | |
| (by linarith) | |
| end ThreeTorus | |
| end | |
| end | |
| section | |
| /-! The two exact support separations in the passage and stage construction. | |
| No spectral or asymptotic separation is substituted for actual disjoint sets. -/ | |
| noncomputable section | |
| open Set Function | |
| open scoped Topology | |
| namespace ThreeTorus | |
| /-- One integral shift separates the speed ranges for all distinct integer | |
| angular indices in a finite list. It also keeps every range away from zero. -/ | |
| theorem exists_integral_speed_separation {ΞΉ X : Type*} [Finite ΞΉ] | |
| [TopologicalSpace X] [CompactSpace X] (m : ΞΉ β β€) (Ο : X β β) | |
| (hm : β i, m i β 0) (hΟ : Continuous Ο) : | |
| β c : β, 0 < c β§ | |
| (β i x, (m i : β) * ((c:β) + Ο x) β 0) β§ | |
| (β i j x y, (m i : β) * ((c:β) + Ο x) = | |
| (m j : β) * ((c:β) + Ο y) β m i = m j) := by | |
| obtain β¨R,hRβ© := (isCompact_range hΟ).isBounded.exists_norm_le | |
| obtain β¨D,hDβ© := (Set.finite_range (fun i => (m i : β))).isCompact.isBounded.exists_norm_le | |
| let B := max R 0 | |
| let M := max D 0 | |
| have hB : 0 β€ B := le_max_right _ _ | |
| have hM : 0 β€ M := le_max_right _ _ | |
| have hΟB x : |Ο x| β€ B := (hR _ (mem_range_self x)).trans (le_max_left _ _) | |
| have hmM i : |(m i : β)| β€ M := (hD _ (mem_range_self i)).trans (le_max_left _ _) | |
| obtain β¨c,hcβ© := exists_nat_gt (2*M*B+B+1) | |
| have hMB : 0 β€ M*B := mul_nonneg hM hB | |
| have hcB : B < (c:β) := by nlinarith | |
| have hcp : (0:β) < c := hB.trans_lt hcB | |
| refine β¨c,by exact_mod_cast hcp,?_,?_β© | |
| Β· intro i x | |
| apply mul_ne_zero (by exact_mod_cast hm i) | |
| have ht := (abs_le.mp (hΟB x)).1 | |
| linarith | |
| Β· intro i j x y he | |
| by_contra hij | |
| have hd : 1 β€ |((m i-m j : β€):β)| := by | |
| exact_mod_cast Int.one_le_abs (sub_ne_zero.mpr hij) | |
| have he' : ((m i:β)-(m j:β))*(c:β) = (m j:β)*Ο y-(m i:β)*Ο x := by | |
| nlinarith [he] | |
| have hh : |(m j:β)*Ο y-(m i:β)*Ο x| β€ 2*M*B := calc | |
| _ β€ |(m j:β)*Ο y|+|(m i:β)*Ο x| := abs_sub _ _ | |
| _ = |(m j:β)| *|Ο y|+|(m i:β)| *|Ο x| := by rw [abs_mul,abs_mul] | |
| _ β€ M*B+M*B := add_le_add | |
| (mul_le_mul (hmM j) (hΟB y) (abs_nonneg _) hM) | |
| (mul_le_mul (hmM i) (hΟB x) (abs_nonneg _) hM) | |
| _ = 2*M*B := by ring | |
| rw [β he',abs_mul,abs_of_pos hcp] at hh | |
| simp only [Int.cast_sub] at hd | |
| nlinarith | |
| /-- A stationary image of an amplitude support. The pair records frequency | |
| and the unchanged slow coordinate. -/ | |
| def stationaryImage (m : β€) (V : β β β) (K : Set (β Γ UnitAddCircle)) : | |
| Set (β Γ UnitAddCircle) := | |
| (fun p : β Γ UnitAddCircle => ((m:β)*V p.1,p.2)) '' K | |
| lemma stationaryImage_compact {m : β€} {V : β β β} {K : Set (β Γ UnitAddCircle)} | |
| (hV : Continuous V) (hK : IsCompact K) : IsCompact (stationaryImage m V K) := | |
| hK.image ((continuous_const.mul (hV.comp continuous_fst)).prodMk continuous_snd) | |
| /-- For equal angular indices, branch injectivity preserves the exact gaps | |
| between disjoint coefficient supports. -/ | |
| lemma stationaryImage_disjoint_same {m : β€} (hm : m β 0) {V : β β β} {I : Set β} | |
| (hV : InjOn V I) {K L : Set (β Γ UnitAddCircle)} | |
| (hK : K β I ΓΛ’ univ) (hL : L β I ΓΛ’ univ) (hd : Disjoint K L) : | |
| Disjoint (stationaryImage m V K) (stationaryImage m V L) := by | |
| rw [Set.disjoint_left] | |
| rintro _ β¨p,hp,rflβ© β¨q,hq,heβ© | |
| have he1 := congrArg Prod.fst he | |
| have he2 := congrArg Prod.snd he | |
| have heV : V q.1 = V p.1 := mul_left_cancelβ (by exact_mod_cast hm) he1 | |
| have hep : q = p := Prod.ext (hV (hL hq).1 (hK hp).1 heV) he2 | |
| exact Set.disjoint_left.mp hd hp (hep βΈ hq) | |
| /-- Different angular indices are separated by their frequency ranges. -/ | |
| lemma stationaryImage_disjoint_distinct {m n : β€} {V : β β β} | |
| {K L : Set (β Γ UnitAddCircle)} | |
| (hsep : β p β K, β q β L, (m:β)*V p.1 β (n:β)*V q.1) : | |
| Disjoint (stationaryImage m V K) (stationaryImage n V L) := by | |
| rw [Set.disjoint_left] | |
| rintro _ β¨p,hp,rflβ© β¨q,hq,heβ© | |
| exact hsep p hp q hq (congrArg Prod.fst he).symm | |
| end ThreeTorus | |
| end | |
| end | |
| end OAI | |