| import Mathlib |
| import OAI.GroupTheory.SimpleAmenable.RandomFields.SignalCutoff |
|
|
| namespace OAI |
|
|
| section |
| section |
| open scoped symmDiff |
| namespace SimpleAmenable |
| open scoped commutatorElement |
| open scoped commutatorElement |
| section SignalGoodRows |
| open Classical |
|
|
| theorem finset_sum_eq_of_zero_outside {ι : Type*} (f : ι → ℝ) (S T : Finset ι) |
| (hS : ∀i,i∉S → f i=0) (hT : ∀i,i∉T → f i=0) : |
| (∑i∈S,f i)=∑i∈T,f i := by |
| calc |
| _ = ∑i∈S∪T,f i := Finset.sum_subset Finset.subset_union_left (fun i _ hi => hS i hi) |
| _ = _ := (Finset.sum_subset Finset.subset_union_right (fun i _ hi => hT i hi)).symm |
|
|
| theorem flagSignal_good_row_constants {a m D : ℕ} {v : ℝ×ℝ} (hD : 0<D) |
| (g : polygonFullGroup a m) (ψ χ : (ℝ×ℝ) → ℝ) |
| (hψ : ContDiff ℝ 2 ψ) (hsψ : HasCompactSupport ψ) (q K : ℝ) |
| (hcompact : ∀x,K ≤ ‖x‖ → ψ x=0) |
| (hχ : ∀x,‖x‖ ≤ K+2 → χ x=1) : |
| ∃R Q Cv Ca : ℝ,0 ≤ R ∧ 0 ≤ Q ∧ 0 ≤ Cv ∧ 0 ≤ Ca ∧ |
| (∀N : ℝ,0<N → ∀z : FlagSite a m D v, |
| |flagSignalDifference hD g (fun x => q+ψ x) N z| ≤ Ca/N) ∧ |
| ∀(N r η κ : ℝ),0<N → Q ≤ N → 0<r → 0<η → η ≤ 1 → 0<κ → |
| 36 ≤ r*η → 1 ≤ 2*κ/(r/N) → R ≤ κ/(r/N) → |
| ∀(z : FlagSite a m D v) (J : Finset (FlagSite a m D v)),flagGoodRow (r/N) κ z → |
| (∀w,w∉J → flagAveragingMatrix χ ((D:ℝ)^4/5) N r η κ z w* |
| flagSignalDifference hD g (fun x => q+ψ x) N w=0) → |
| |(∑w∈J,flagAveragingMatrix χ ((D:ℝ)^4/5) N r η κ z w* |
| flagSignalDifference hD g (fun x => q+ψ x) N w)- |
| flagSignalDifference hD g (fun x => q+ψ x) N z| ≤ |
| (Cv*η/N)*(1+38880/((D:ℝ)*Real.sqrt (r*η)))+ |
| (Ca/N)*(38880/((D:ℝ)*Real.sqrt (r*η))) := by |
| obtain ⟨R,hR,hcharts⟩ := flagAffineData_separator_control (v:=v) g⁻¹ |
| obtain ⟨Q,hQ,hcutoff⟩ := flagSignalDifference_cutoff (v:=v) hD g ψ χ q hcompact hχ |
| obtain ⟨Cv,hCv,hvar⟩ := flagSignalDifference_chart_variation (v:=v) hD g ψ hψ hsψ q |
| obtain ⟨Ca,hCa,hamp⟩ := compactSignal_amplitude (v:=v) hD g ψ hψ hsψ q |
| refine ⟨R,Q,Cv,Ca,hR,hQ,hCv,hCa,hamp,fun N r η κ hN hQN hr hη hη₁ hκ hscale hline hRf z J hz hJ => ?_⟩ |
| let h := flagSignalDifference (v:=v) hD g (fun x => q+ψ x) N |
| obtain ⟨T,hT,herror⟩ := flagAveragingMatrix_good_row_error hD χ h hN hr hη hκ hscale hline |
| (show 0 ≤ Cv*η/N by positivity) z hz (hamp N hN z) (hcutoff N r η hN hQN hη hη₁ z) (by |
| intro w hw |
| obtain ⟨ht,hord,hconj⟩ := (flagRowTent_ne_zero_iff _ _ _ _).mp hw |
| have hsep := flagRowTent_separator_one (div_pos hr hN) hκ (N*η) z w hz hw |
| have hchart : flagAffineData g⁻¹ z.val.1 z.val.2=flagAffineData g⁻¹ w.val.1 w.val.2 := by |
| rw [← ht] |
| exact hcharts (r/N) κ (div_pos hr hN) hκ hRf z.val.1 z.val.2 w.val.2 (by rw [hsep]; norm_num) |
| have hv := hvar N η hN hη.le z w hchart (planeTent_scaled_near hN hη z w hconj) |
| simpa only [abs_sub_comm] using hv) |
| have he := finset_sum_eq_of_zero_outside |
| (fun w => flagAveragingMatrix χ ((D:ℝ)^4/5) N r η κ z w*h w) J T hJ hT |
| change |(∑w∈J,flagAveragingMatrix χ ((D:ℝ)^4/5) N r η κ z w*h w)-h z| ≤ _ |
| rw [he] |
| exact herror |
|
|
| end SignalGoodRows |
|
|
| section SignalActiveBox |
| open Classical |
|
|
| noncomputable def flagBoxFinset {a m D : ℕ} {v : ℝ×ℝ} (hD : 0<D) {R : ℝ} (hR : 0<R) : |
| Finset (FlagSite a m D v) := (flagSiteBox_finite (v:=v) hD hR).toFinset |
|
|
| @[simp] theorem mem_flagBoxFinset {a m D : ℕ} {v : ℝ×ℝ} (hD : 0<D) {R : ℝ} (hR : 0<R) |
| (z : FlagSite a m D v) : z∈flagBoxFinset hD hR ↔ z∈flagSiteBox R := |
| Set.Finite.mem_toFinset _ |
|
|
| theorem flagAveragingMatrix_box_support {a m D : ℕ} {v : ℝ×ℝ} (hD : 0<D) |
| (χ : (ℝ×ℝ) → ℝ) {L N : ℝ} (hL : 0<L) (hN : 0<N) |
| (hχc : ∀x,L ≤ ‖x‖ → χ x=0) (ρ r η κ : ℝ) (z w : FlagSite a m D v) |
| (hz : z∉flagBoxFinset hD (mul_pos hN hL) ∨ w∉flagBoxFinset hD (mul_pos hN hL)) : |
| flagAveragingMatrix χ ρ N r η κ z w=0 := by |
| rcases hz with hz | hw |
| · exact flagAveragingMatrix_cutoff_left χ ρ N r η κ z w |
| (flagMeanSignal_outside χ hN hχc z (by simpa only [mem_flagBoxFinset] using hz)) |
| · exact flagAveragingMatrix_cutoff_right χ ρ N r η κ z w |
| (flagMeanSignal_outside χ hN hχc w (by simpa only [mem_flagBoxFinset] using hw)) |
|
|
| theorem flagSignal_box_support {a m D : ℕ} {v : ℝ×ℝ} (hD : 0<D) |
| (g : polygonFullGroup a m) (ψ : (ℝ×ℝ) → ℝ) (q : ℝ) {K L : ℝ} |
| (hL : 0<L) (hKL : K+1 ≤ L) (hcompact : ∀x,K ≤ ‖x‖ → ψ x=0) : |
| ∃Q : ℝ,0 ≤ Q ∧ ∀(N : ℝ) (hN : 0<N),Q ≤ N → ∀z : FlagSite a m D v, |
| z∉flagBoxFinset hD (mul_pos hN hL) → |
| flagSignalDifference hD g (fun x => q+ψ x) N z=0 := by |
| obtain ⟨Q,hQ,hdisp⟩ := scaledSiteConjugate_displacement (v:=v) hD g⁻¹ |
| refine ⟨Q,hQ,fun N hN hQN z hz => ?_⟩ |
| by_contra hh |
| have hn := flagSignalDifference_ne_zero_near hD g ψ q hcompact hQ hN (hdisp N hN) z hh |
| simp only [scaledSiteConjugate] at hn |
| have hqn : Q/N ≤ 1 := (div_le_one hN).mpr hQN |
| have hx := norm_fst_le (scaledSiteConjugate N z) |
| have hy := norm_snd_le (scaledSiteConjugate N z) |
| simp only [scaledSiteConjugate,Real.norm_eq_abs,abs_div,abs_of_pos hN] at hx hy |
| apply hz |
| rw [mem_flagBoxFinset] |
| have hxL : |(flagSiteConjugate z).1|/N ≤ L := by linarith |
| have hyL : |(flagSiteConjugate z).2|/N ≤ L := by linarith |
| exact ⟨by simpa only [mul_comm L N] using (div_le_iff₀ hN).mp hxL, |
| by simpa only [mul_comm L N] using (div_le_iff₀ hN).mp hyL⟩ |
|
|
| theorem flagBoxFinset_card_quadratic {a m D : ℕ} {v : ℝ×ℝ} (hD : 0<D) {L N : ℝ} |
| (hL : 0<L) (hN : 1 ≤ N) : |
| ((flagBoxFinset (a:=a) (m:=m) (v:=v) hD |
| (mul_pos (lt_of_lt_of_le zero_lt_one hN) hL)).card:ℝ) ≤ |
| (m*(2*(D:ℝ)^2*L+2)^2)*N^2 := by |
| have hN' : 0<N := lt_of_lt_of_le zero_lt_one hN |
| have hh := flagSiteBox_card_bound (a:=a) (m:=m) (v:=v) hD (mul_pos hN' hL) |
| (flagBoxFinset hD (mul_pos hN' hL)) (fun z hz => (mem_flagBoxFinset _ _ _).mp hz) |
| have he : 2*(D:ℝ)^2*(N*L)+2 ≤ (2*(D:ℝ)^2*L+2)*N := by nlinarith |
| refine hh.trans ?_ |
| calc |
| _ ≤ m*((2*(D:ℝ)^2*L+2)*N)^2 := by gcongr |
| _ = _ := by ring |
| |
| end SignalActiveBox |
| |
| section ApproximationEnergy |
| open Classical |
| |
| noncomputable def flagVolumeConstant (m D : ℕ) (Q : ℝ) : ℝ := m*(2*(D:ℝ)^2*Q+2)^2 |
| noncomputable def flagExceptionalConstant (a m D : ℕ) (Q : ℝ) : ℝ := |
| 4*(m*(4*(D:ℝ)^2*(1+|conjugate (cutTau^a)|)*(1+|ordinary (cutTau^a)|)*Q+2)* |
| (2*(D:ℝ)^2*Q+2)*(16*(1+|ordinary (cutTau^a)|)+2)) |
| noncomputable def flagRowSumConstant (D : ℕ) : ℝ := (4*(D:ℝ)^2+2)^2/((D:ℝ)^4/5)+1 |
| |
| theorem flag_good_bad_energy {a m D : ℕ} {v : ℝ×ℝ} (hD : 0<D) |
| {Q κ s N E H : ℝ} (hQ : 0<Q) (hκ : 0<κ) (hs : 0<s) (hs₁ : s ≤ 1) |
| (hN : 1 ≤ N) (hscale : 1 ≤ s*N) (hE : 0 ≤ E) (hH : 0 ≤ H) |
| (T : Finset (FlagSite a m D v)) (hT : ∀z∈T,z∈flagSiteBox (Q*N)) |
| (e : FlagSite a m D v → ℝ) |
| (hgood : ∀z∈T,flagGoodRow s κ z → |e z| ≤ E/N) |
| (hbad : ∀z∈T,|e z| ≤ H/N) : |
| ∑z∈T,(e z)^2 ≤ flagVolumeConstant m D Q*E^2+ |
| flagExceptionalConstant a m D Q*(κ+s)*H^2 := by |
| have hN' : 0<N := lt_of_lt_of_le zero_lt_one hN |
| let B := T.filter (fun z => ¬flagGoodRow s κ z) |
| have hb : (B.card:ℝ) ≤ flagExceptionalConstant a m D Q*(κ+s)*N^2 := by |
| apply flagBadSeparatorRow_card_bound hD hQ hκ hs hs₁ hN hscale B |
| intro z hz |
| obtain ⟨hzt,hzb⟩ := Finset.mem_filter.mp hz |
| refine ⟨hT z hzt,?_⟩ |
| simp only [flagGoodRow,not_forall,not_lt] at hzb |
| obtain ⟨j,c,hc,he⟩ := hzb |
| exact ⟨j,c,hc,he⟩ |
| have ht : (T.card:ℝ) ≤ flagVolumeConstant m D Q*N^2 := by |
| have hh := flagSiteBox_card_bound hD (mul_pos hQ hN') T hT |
| have he : 2*(D:ℝ)^2*(Q*N)+2 ≤ (2*(D:ℝ)^2*Q+2)*N := by nlinarith |
| refine hh.trans ?_ |
| calc |
| _ ≤ m*((2*(D:ℝ)^2*Q+2)*N)^2 := by gcongr |
| _ = _ := by dsimp [flagVolumeConstant]; ring |
| have hh := squared_error_good_bad T B e (div_nonneg hE hN'.le) (div_nonneg hH hN'.le) |
| (by |
| intro z hz hzb |
| apply hgood z hz |
| by_contra he |
| exact hzb (Finset.mem_filter.mpr ⟨hz,he⟩)) hbad |
| refine hh.trans ?_ |
| calc |
| _ ≤ (flagVolumeConstant m D Q*N^2)*(E/N)^2+ |
| (flagExceptionalConstant a m D Q*(κ+s)*N^2)*(H/N)^2 := by |
| gcongr |
| _ = _ := by field_simp |
| |
| end ApproximationEnergy |
| |
| end SimpleAmenable |
| end |
| end |
| |
| end OAI |
| |
