File size: 4,638 Bytes
4a56cd6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 | import OAI.Analysis.Fourier.Restriction.FiniteCover
import OAI.Analysis.Fourier.Restriction.BallCover
open OAI.Analysis.Fourier.Wave
open _root_.MeasureTheory Set Metric
open scoped ENNReal BigOperators
noncomputable section
namespace OAI.Analysis.Fourier.Restriction
/-- The sparse-ball estimate used in epsilon removal. The separation depends
polynomially on both radius and the actual number of centers. -/
def SparseFourierBound (n : β) (p : ββ₯0β) (Ξ± : β) (D : β) (C : ββ₯0β) : Prop :=
β R : β, 1 β€ R β β T : Finset (Space n),
(β z β T, β w β T, z β w β R ^ D * (T.card : β) ^ D β€ dist z w) β
β f : Space n β β, Measurable f β Integrable f β
(β x, (β z β T, x β ball z R) β f x = 0) β
eLpNorm (OAI.Analysis.Fourier.LocalSmoothing.angularFourier f) p (OAI.Analysis.Fourier.Restriction.sphereMeasure n) β€
C * ENNReal.ofReal (R ^ Ξ±) * eLpNorm f p volume
/-- Sparse estimates and the quantitative geometric cover give an explicit
norm bound on every finite union of unit balls. -/
theorem sparseFourierBound_unit_ball_cover {n : β} {p : ββ₯0β} (hp : 1 β€ p)
{Ξ± : β} (hΞ± : 0 β€ Ξ±) {D : β} (hD : 0 < D) {C : ββ₯0β}
(hSparse : SparseFourierBound n p Ξ± D C)
(E : Finset (Space n)) (M N : β) (hM : 1 β€ M) (hcard : E.card β€ M) (hN : 0 < N)
{f : Space n β β} (hf : Measurable f) (hfi : Integrable f)
(hfs : β x, (β e β E, x β ball e 1) β f x = 0) :
eLpNorm (OAI.Analysis.Fourier.LocalSmoothing.angularFourier f) p (OAI.Analysis.Fourier.Restriction.sphereMeasure n) β€
ENNReal.ofReal (3 * N * (M : β) ^ (1 / (N : β))) *
(C * ENNReal.ofReal ((5 * (4 * ((M : β) + 1)) ^ ((3 * D + 1) ^ N)) ^ Ξ±)) *
eLpNorm f p volume := by
classical
obtain β¨K, T, c, hcount, hTE, hsep, hcover, hRβ© :=
unit_ball_sparse_cover E M N D hM hcard hN hD
let S (i : Fin N Γ Fin (K + 1)) := (T i.1).filter (fun z β¦ c i.1 z = i.2)
let R (j : Fin N) := 5 * sparseScale M D j
let Rmax : β := 5 * (4 * ((M : β) + 1)) ^ ((3 * D + 1) ^ N)
let U (i : Fin N Γ Fin (K + 1)) := β z β S i, ball z (R i.1)
have hUm : β i, MeasurableSet (U i) := by
intro i
exact (isOpen_iUnion fun z β¦ isOpen_iUnion fun _ β¦ isOpen_ball).measurableSet
have hRi (j : Fin N) : 1 β€ R j := by
have H := sparseScale_ge_four M D j
dsimp [R]
linarith
have hSi (i : Fin N Γ Fin (K + 1)) : (S i).card β€ M :=
(Finset.card_le_card (Finset.filter_subset _ _)).trans
((Finset.card_le_card (hTE i.1)).trans hcard)
have hSsep (i : Fin N Γ Fin (K + 1)) : β z β S i, β w β S i,
z β w β (R i.1) ^ D * ((S i).card : β) ^ D β€ dist z w := by
intro z hz w hw hzw
have hz' := Finset.mem_filter.mp hz
have hw' := Finset.mem_filter.mp hw
have H := hsep i.1 z hz'.1 w hw'.1 hzw (hz'.2.trans hw'.2.symm)
apply le_trans _ H
apply mul_le_mul_of_nonneg_left _ (pow_nonneg (le_trans zero_le_one (hRi i.1)) D)
exact pow_le_pow_leftβ (Nat.cast_nonneg _) (by exact_mod_cast hSi i) D
have H := fourier_bound_of_finite_cover Finset.univ U hUm
(fun i β¦ C * ENNReal.ofReal ((R i.1) ^ Ξ±)) hp (fun i _ g hgm hgi hgs β¦ by
apply hSparse (R i.1) (hRi i.1) (S i) (hSsep i) g hgm hgi
intro x hx
apply hgs x
simp only [U, mem_iUnion, not_exists]
exact hx) hf hfi (fun x hx β¦ by
apply hfs x
intro e he hxe
obtain β¨j, y, hy, hxyβ© := hcover x β¨e, he, hxeβ©
apply hx (j, c j y) (Finset.mem_univ _)
change x β β z β S (j, c j y), ball z (R j)
exact mem_iUnion.mpr β¨y, mem_iUnion.mpr β¨Finset.mem_filter.mpr β¨hy, rflβ©, hxyβ©β©)
have hsum : (β i : Fin N Γ Fin (K + 1), C * ENNReal.ofReal ((R i.1) ^ Ξ±)) β€
((N * (K + 1) : β) : ββ₯0β) * (C * ENNReal.ofReal (Rmax ^ Ξ±)) := by
calc
_ β€ β _i : Fin N Γ Fin (K + 1), C * ENNReal.ofReal (Rmax ^ Ξ±) := by
apply Finset.sum_le_sum
intro i _
apply mul_le_mul le_rfl _ zero_le zero_le
apply ENNReal.ofReal_le_ofReal
exact Real.rpow_le_rpow (le_trans zero_le_one (hRi i.1)) (hR i.1) hΞ±
_ = _ := by simp [Fintype.card_prod, nsmul_eq_mul]
have hcountE : ((N * (K + 1) : β) : ββ₯0β) β€
ENNReal.ofReal (3 * N * (M : β) ^ (1 / (N : β))) := by
simpa only [ENNReal.ofReal_natCast] using ENNReal.ofReal_le_ofReal hcount
exact H.trans (mul_le_mul (hsum.trans (mul_le_mul hcountE le_rfl zero_le zero_le)) le_rfl zero_le zero_le)
end OAI.Analysis.Fourier.Restriction
|