| import Mathlib |
| import OAI.Probability.GaussianInformation.Dyadic.Tubes |
|
|
| namespace OAI |
| open MeasureTheory ProbabilityTheory Set |
| open scoped BigOperators ENNReal |
| open MeasureTheory Metric Set |
| open scoped ENNReal NNReal |
| namespace RepeatedLocalization |
|
|
| noncomputable def eCoordinate {n : ℕ} (z : Coordinate n) : EuclideanSpace ℝ (Fin n) := |
| WithLp.toLp 2 z |
| noncomputable def eChart {n : ℕ} (z : Coordinate n) : EuclideanSpace ℝ (Fin (n+1)) := |
| WithLp.toLp 2 (chart z) |
|
|
| lemma norm_eCoordinate_le_half {n : ℕ} (hn : 0 < n) {z : Coordinate n} |
| (hz : z ∈ initialCube n) : ‖eCoordinate z‖ ≤ 1/2 := by |
| have hs : 0 < Real.sqrt (n : ℝ) := Real.sqrt_pos.mpr (by exact_mod_cast hn) |
| have hsq : ‖eCoordinate z‖^2 ≤ (1/2 : ℝ)^2 := by |
| rw [EuclideanSpace.real_norm_sq_eq] |
| calc |
| _ ≤ ∑ i : Fin n, (1 / (2 * Real.sqrt n))^2 := Finset.sum_le_sum fun i _ => by |
| have hl := hz i (mem_univ i) |
| simp only [mem_Ico, neg_div] at hl |
| change (z i)^2 ≤ _ |
| have ha : |z i| ≤ 1 / (2 * Real.sqrt n) := abs_le.mpr ⟨hl.1, hl.2.le⟩ |
| nlinarith [sq_abs (z i), abs_nonneg (z i)] |
| _ = _ := by |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] |
| have hsq := Real.sq_sqrt (show (0 : ℝ) ≤ n from Nat.cast_nonneg _) |
| field_simp |
| nlinarith |
| nlinarith [norm_nonneg (eCoordinate z)] |
|
|
| lemma chart_height_lipschitz {E : Type*} [SeminormedAddCommGroup E] |
| {x y : E} (hx : ‖x‖ ≤ 1/2) (hy : ‖y‖ ≤ 1/2) : |
| |Real.sqrt (1 - ‖x‖^2) - Real.sqrt (1 - ‖y‖^2)| ≤ ‖x-y‖ := by |
| have ax := norm_nonneg x |
| have ay := norm_nonneg y |
| have hx0 : 0 ≤ 1 - ‖x‖^2 := by nlinarith |
| have hy0 : 0 ≤ 1 - ‖y‖^2 := by nlinarith |
| have hx2 := Real.sq_sqrt hx0 |
| have hy2 := Real.sq_sqrt hy0 |
| have hx1 : 1/2 ≤ Real.sqrt (1 - ‖x‖^2) := by nlinarith [Real.sqrt_nonneg (1-‖x‖^2)] |
| have hy1 : 1/2 ≤ Real.sqrt (1 - ‖y‖^2) := by nlinarith [Real.sqrt_nonneg (1-‖y‖^2)] |
| have he : |Real.sqrt (1 - ‖x‖^2) - Real.sqrt (1 - ‖y‖^2)| * |
| (Real.sqrt (1 - ‖x‖^2) + Real.sqrt (1 - ‖y‖^2)) = |
| |‖y‖ - ‖x‖| * (‖y‖ + ‖x‖) := by |
| rw [← abs_of_nonneg (by positivity : 0 ≤ Real.sqrt (1 - ‖x‖^2) + Real.sqrt (1 - ‖y‖^2)), |
| ← abs_mul, ← abs_of_nonneg (add_nonneg ay ax), ← abs_mul] |
| congr 1 |
| nlinarith |
| have hn := abs_norm_sub_norm_le y x |
| rw [norm_sub_rev y x] at hn |
| have hsum : ‖y‖ + ‖x‖ ≤ 1 := by linarith |
| have hp := mul_le_mul hn hsum (add_nonneg ay ax) (norm_nonneg (x-y)) |
| have hab := abs_nonneg (Real.sqrt (1 - ‖x‖^2) - Real.sqrt (1 - ‖y‖^2)) |
| nlinarith |
|
|
| lemma eChart_dist_le {n : ℕ} (hn : 0 < n) {z w : Coordinate n} |
| (hz : z ∈ initialCube n) (hw : w ∈ initialCube n) : |
| dist (eChart z) (eChart w) ≤ 2 * dist (eCoordinate z) (eCoordinate w) := by |
| have hheight := chart_height_lipschitz (norm_eCoordinate_le_half hn hz) (norm_eCoordinate_le_half hn hw) |
| have hs : ‖eChart z - eChart w‖^2 = ‖eCoordinate z - eCoordinate w‖^2 + |
| (Real.sqrt (1-‖eCoordinate z‖^2) - Real.sqrt (1-‖eCoordinate w‖^2))^2 := by |
| simp only [EuclideanSpace.real_norm_sq_eq, eChart, eCoordinate, |
| PiLp.sub_apply, chart, Fin.sum_univ_castSucc, Fin.lastCases_castSucc, Fin.lastCases_last] |
| rw [dist_eq_norm, dist_eq_norm] |
| have ha := abs_nonneg (Real.sqrt (1-‖eCoordinate z‖^2) - Real.sqrt (1-‖eCoordinate w‖^2)) |
| have hb := norm_nonneg (eCoordinate z - eCoordinate w) |
| have hc := norm_nonneg (eChart z - eChart w) |
| nlinarith [sq_abs (Real.sqrt (1-‖eCoordinate z‖^2) - Real.sqrt (1-‖eCoordinate w‖^2))] |
|
|
| noncomputable def firstCoordinates {n : ℕ} (v : EuclideanSpace ℝ (Fin (n+1))) : |
| EuclideanSpace ℝ (Fin n) := WithLp.toLp 2 (fun i => v i.castSucc) |
|
|
| lemma firstCoordinates_lipschitz (n : ℕ) : LipschitzWith 1 (firstCoordinates (n := n)) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro x y |
| simp only [NNReal.coe_one, one_mul, dist_eq_norm] |
| have hs : ‖firstCoordinates x - firstCoordinates y‖^2 ≤ ‖x-y‖^2 := by |
| simp only [EuclideanSpace.real_norm_sq_eq] |
| rw [Fin.sum_univ_castSucc] |
| change (∑ i : Fin n, (x i.castSucc - y i.castSucc)^2) ≤ |
| (∑ i : Fin n, (x i.castSucc - y i.castSucc)^2) + (x (Fin.last n)-y (Fin.last n))^2 |
| nlinarith [sq_nonneg (x (Fin.last n)-y (Fin.last n))] |
| nlinarith [norm_nonneg (firstCoordinates x-firstCoordinates y), norm_nonneg (x-y)] |
|
|
| noncomputable def normalizedChart {n : ℕ} (Q : Cell n) (z : Coordinate n) : |
| EuclideanSpace ℝ (Fin (n+1)) := (2 : ℝ)^Q.1 • (eChart z - eChart (cellCenter Q)) |
|
|
| lemma normalizedChart_norm_le {n : ℕ} (hn : 0 < n) (Q : Cell n) |
| {z : Coordinate n} (hz : z ∈ cellSet Q) : ‖normalizedChart Q z‖ ≤ 2 := by |
| have hchart := eChart_dist_le hn (cellSet_subset_initialCube hn Q hz) |
| (cellSet_subset_initialCube hn Q (cellCenter_mem hn Q)) |
| have hgrid : ∀ w ∈ cellSet Q, eCoordinate w ∈ euclideanGridCell (cellLower Q) (cellWidth n Q.1) 0 := by |
| intro w hw i |
| rw [cellSet_eq_pi] at hw |
| have hi := hw i (mem_univ i) |
| simpa [euclideanGridCell, eCoordinate] using hi |
| have hdiam := dist_le_of_mem_euclideanGridCell (cellLower Q) (cellWidth_pos hn).le 0 |
| (hgrid z hz) (hgrid _ (cellCenter_mem hn Q)) |
| have hp : 0 < (2 : ℝ)^Q.1 := by positivity |
| have hs : Real.sqrt (n : ℝ) ≠ 0 := (Real.sqrt_pos.mpr (by exact_mod_cast hn)).ne' |
| have he : (2 : ℝ)^Q.1 * (Real.sqrt n * cellWidth n Q.1) = 1 := by |
| unfold cellWidth |
| field_simp |
| unfold normalizedChart |
| rw [norm_smul, Real.norm_of_nonneg hp.le, ← dist_eq_norm] |
| calc |
| _ ≤ (2 : ℝ)^Q.1 * (2 * (Real.sqrt n * cellWidth n Q.1)) := |
| mul_le_mul_of_nonneg_left (hchart.trans (mul_le_mul_of_nonneg_left hdiam (by norm_num))) hp.le |
| _ = 2 := by nlinarith [he] |
| |
| lemma normalizedChart_measurable {n : ℕ} (Q : Cell n) : Measurable (normalizedChart Q) := by |
| unfold normalizedChart eChart |
| have hc : Measurable (chart (n := n)) := measurable_chart n |
| fun_prop |
| |
| noncomputable def normalizedGridBase {n : ℕ} (Q : Cell n) : Fin n → ℝ := |
| fun i => (2 : ℝ)^Q.1 * (cellLower Q i - cellCenter Q i) |
| |
| lemma normalizedGrid_mem_iff {n : ℕ} (Q : Cell n) (l : ℕ) (v : Fin n → ℤ) (z : Coordinate n) : |
| firstCoordinates (normalizedChart Q z) ∈ euclideanGridCell (normalizedGridBase Q) |
| ((2 : ℝ)^Q.1 * cellWidth n (Q.1+l)) v ↔ |
| ∀ i, cellLower Q i + cellWidth n (Q.1+l) * (v i : ℝ) ≤ z i ∧ |
| z i < cellLower Q i + cellWidth n (Q.1+l) * ((v i : ℝ)+1) := by |
| have hp : 0 < (2 : ℝ)^Q.1 := by positivity |
| have he (i : Fin n) : firstCoordinates (normalizedChart Q z) i = |
| (2 : ℝ)^Q.1 * (z i - cellCenter Q i) := by |
| simp [firstCoordinates, normalizedChart, eChart, chart] |
| simp only [euclideanGridCell, mem_ofPred_eq, he, normalizedGridBase] |
| apply forall_congr' |
| intro i |
| constructor |
| · intro h |
| constructor |
| · have hh : (2 : ℝ)^Q.1 * (cellLower Q i + cellWidth n (Q.1+l)*(v i : ℝ) - cellCenter Q i) ≤ |
| (2 : ℝ)^Q.1 * (z i - cellCenter Q i) := by nlinarith [h.1] |
| have hh' := (mul_le_mul_iff_right₀ hp).mp hh |
| linarith |
| · have hh : (2 : ℝ)^Q.1 * (z i - cellCenter Q i) < |
| (2 : ℝ)^Q.1 * (cellLower Q i + cellWidth n (Q.1+l)*((v i : ℝ)+1) - cellCenter Q i) := by |
| nlinarith [h.2] |
| have hh' := (mul_lt_mul_iff_right₀ hp).mp hh |
| linarith |
| · intro h |
| constructor |
| · have hh := mul_le_mul_of_nonneg_left (sub_le_sub_right h.1 (cellCenter Q i)) hp.le |
| nlinarith |
| · have hh := mul_lt_mul_of_pos_left (sub_lt_sub_right h.2 (cellCenter Q i)) hp |
| nlinarith |
|
|
| lemma normalizedGrid_valid_of_inter {n : ℕ} (hn : 0 < n) (Q : Cell n) (l : ℕ) |
| (v : Fin n → ℤ) {z : Coordinate n} (hz : z ∈ cellSet Q) |
| (hg : firstCoordinates (normalizedChart Q z) ∈ euclideanGridCell (normalizedGridBase Q) |
| ((2 : ℝ)^Q.1 * cellWidth n (Q.1+l)) v) : ∀ i, 0 ≤ v i ∧ v i < (2^l : ℕ) := by |
| rw [normalizedGrid_mem_iff] at hg |
| rw [cellSet_eq_pi] at hz |
| intro i |
| have hh := hz i (mem_univ i) |
| dsimp only at hh |
| have hw := cellWidth_pos (J := Q.1+l) hn |
| have he : cellWidth n (Q.1+l) * (2 : ℝ)^l = cellWidth n Q.1 := by |
| rw [cellWidth_add, div_mul_cancel₀ _ (pow_ne_zero _ (by norm_num))] |
| have hlr : (-1 : ℝ) < (v i : ℝ) := by |
| by_contra h |
| have hb := mul_le_mul_of_nonneg_left (le_of_not_gt h) hw.le |
| nlinarith [hh.1, (hg i).2] |
| have hur : (v i : ℝ) < (2 : ℝ)^l := by |
| by_contra h |
| have hb := mul_le_mul_of_nonneg_left (le_of_not_gt h) hw.le |
| nlinarith [hh.2, (hg i).1] |
| constructor |
| · have : (-1 : ℤ) < v i := by exact_mod_cast hlr |
| omega |
| · exact_mod_cast hur |
|
|
| lemma normalizedGrid_child_mem {n : ℕ} (Q : Cell n) (l : ℕ) (a : Fin n → Fin (2^l)) |
| {z : Coordinate n} |
| (hg : firstCoordinates (normalizedChart Q z) ∈ euclideanGridCell (normalizedGridBase Q) |
| ((2 : ℝ)^Q.1 * cellWidth n (Q.1+l)) (fun i => (a i).val)) : |
| z ∈ cellSet (childCell Q l a) := by |
| rw [normalizedGrid_mem_iff] at hg |
| rw [cellSet_eq_pi] |
| intro i hi |
| dsimp only |
| rw [childCell_lower] |
| have h := hg i |
| simp only [Int.cast_natCast] at h |
| change cellLower Q i + cellWidth n (Q.1+l)*(a i : ℝ) ≤ z i ∧ |
| z i < cellLower Q i + cellWidth n (Q.1+l)*(a i : ℝ) + cellWidth n (Q.1+l) |
| constructor <;> nlinarith [h.1, h.2] |
|
|
| lemma measure_normalizedGrid_le {n : ℕ} (hn : 0 < n) (Q : Cell n) (l : ℕ) |
| (μ : Measure (Coordinate n)) (hsupport : μ (cellSet Q)ᶜ = 0) |
| (b : ℝ≥0∞) (hchild : ∀ a, μ (cellSet (childCell Q l a)) ≤ b) (v : Fin n → ℤ) : |
| μ ((firstCoordinates ∘ normalizedChart Q) ⁻¹' euclideanGridCell (normalizedGridBase Q) |
| ((2 : ℝ)^Q.1 * cellWidth n (Q.1+l)) v) ≤ b := by |
| classical |
| have hae : ∀ᵐ z ∂μ, z ∈ cellSet Q := by |
| apply ae_iff.mpr |
| exact hsupport |
| by_cases hv : ∀ i, 0 ≤ v i ∧ v i < (2^l : ℕ) |
| · let a : Fin n → Fin (2^l) := fun i => ⟨(v i).toNat, by |
| exact (Int.toNat_lt (hv i).1).mpr (hv i).2⟩ |
| have he : (fun i => ((a i).val : ℤ)) = v := by |
| funext i |
| exact Int.toNat_of_nonneg (hv i).1 |
| refine (measure_mono_ae (hae.mono (fun z _ hg => ?_))).trans (hchild a) |
| apply normalizedGrid_child_mem Q l a |
| change firstCoordinates (normalizedChart Q z) ∈ euclideanGridCell (normalizedGridBase Q) |
| ((2 : ℝ)^Q.1 * cellWidth n (Q.1+l)) v at hg |
| simpa only [he] using hg |
| · have hempty : μ ((firstCoordinates ∘ normalizedChart Q) ⁻¹' euclideanGridCell (normalizedGridBase Q) |
| ((2 : ℝ)^Q.1 * cellWidth n (Q.1+l)) v) = 0 := by |
| apply measure_mono_null (t := (cellSet Q)ᶜ) _ hsupport |
| intro z hg hz |
| exact hv (normalizedGrid_valid_of_inter hn Q l v hz hg) |
| rw [hempty] |
| exact bot_le |
|
|
| def DyadicSpread {n : ℕ} (μ : Measure (Coordinate n)) (Q : Cell n) (B : ℝ) : Prop := |
| ∀ (l : ℕ) (R : Cell n), R.1 = Q.1 + l → cellSet R ⊆ cellSet Q → |
| μ (cellSet R) ≤ ENNReal.ofReal (B * (2 : ℝ)^(-(n : ℝ)*l/2)) |
|
|
| lemma DyadicSpread.child_floor {n : ℕ} (hn : 0 < n) {μ : Measure (Coordinate n)} |
| {Q : Cell n} {B : ℝ} (hB : 0 ≤ B) (h : DyadicSpread μ Q B) (l : ℕ) |
| (a : Fin n → Fin (2^l)) : |
| μ (cellSet (childCell Q l a)) ≤ ENNReal.ofReal (B * (1/2 : ℝ)^((n/2)*l)) := by |
| refine (h l (childCell Q l a) rfl (childCell_subset hn Q l a)).trans ?_ |
| apply ENNReal.ofReal_le_ofReal |
| apply mul_le_mul_of_nonneg_left _ hB |
| have hdiv : ((n/2 : ℕ) : ℝ) * 2 ≤ n := by exact_mod_cast Nat.div_mul_le_self n 2 |
| have he : -(n : ℝ) * l / 2 ≤ -(((n/2)*l : ℕ) : ℝ) := by |
| simp only [Nat.cast_mul] |
| nlinarith [mul_nonneg (show (0 : ℝ) ≤ l from Nat.cast_nonneg _) (sub_nonneg.mpr hdiv)] |
| have hr := Real.rpow_le_rpow_of_exponent_le (by norm_num : (1 : ℝ) ≤ 2) he |
| simpa only [Real.rpow_neg (by norm_num : (0 : ℝ) ≤ 2), Real.rpow_natCast, one_div, inv_pow] using hr |
|
|
| noncomputable def gridConstant : ℝ := 3 * (Real.exp 1 * Real.sqrt Real.pi) |
| noncomputable def tubeConstant : ℝ := 13 * max 1 gridConstant |
|
|
| lemma gridConstant_nonneg : 0 ≤ gridConstant := by unfold gridConstant; positivity |
| lemma tubeConstant_ge_one : 1 ≤ tubeConstant := by |
| unfold tubeConstant |
| nlinarith [le_max_left (1 : ℝ) gridConstant] |
|
|
| lemma dyadic_tube_tail {n : ℕ} (hn : 0 < n) (Q : Cell n) |
| (μ : Measure (Coordinate n)) (hsupport : μ (cellSet Q)ᶜ = 0) |
| {B : ℝ} (hB : 0 ≤ B) (hspread : DyadicSpread μ Q B) |
| (V : AffineSubspace ℝ (EuclideanSpace ℝ (Fin (n+1)))) (hV : (V : Set (EuclideanSpace ℝ (Fin (n+1)))).Nonempty) |
| (e : ℕ) (he : Module.finrank ℝ V.direction + e ≤ n/2) (j : ℕ) : |
| μ {z | infDist (normalizedChart Q z) (V : Set (EuclideanSpace ℝ (Fin (n+1)))) ≤ (1/2 : ℝ)^j} ≤ |
| ENNReal.ofReal (B * tubeConstant^n * (1/2 : ℝ)^(e*j)) := by |
| let δ : ℝ := (1/2 : ℝ)^j |
| let q := Module.finrank ℝ V.direction |
| have hd : 0 < δ := by dsimp [δ]; positivity |
| have hd1 : δ ≤ 1 := pow_le_one₀ (by norm_num) (by norm_num) |
| have hw : 0 < (2 : ℝ)^Q.1 * cellWidth n (Q.1+j) := mul_pos (by positivity) (cellWidth_pos hn) |
| have hs : Real.sqrt (n : ℝ) ≠ 0 := (Real.sqrt_pos.mpr (by exact_mod_cast hn)).ne' |
| have hscale : Real.sqrt n * ((2 : ℝ)^Q.1 * cellWidth n (Q.1+j)) = δ := by |
| dsimp [cellWidth, δ] |
| rw [pow_add] |
| simp only [one_div, inv_pow] |
| field_simp |
| have ht := measure_affine_tube_le_of_grid μ hn (normalizedChart Q) firstCoordinates |
| (firstCoordinates_lipschitz n) V hV (normalizedGridBase Q) hw (by norm_num : (0:ℝ) ≤ 2) |
| hd (by norm_num : (0:ℝ) ≤ 2) (by rw [hscale]) |
| (ENNReal.ofReal (B * δ^(n/2))) |
| (fun v => measure_normalizedGrid_le hn Q j μ hsupport _ |
| (fun a => by simpa only [δ, ← pow_mul, Nat.mul_comm j (n/2)] using hspread.child_floor hn hB j a) v) |
| have hae : ∀ᵐ z ∂μ, z ∈ cellSet Q := by exact ae_iff.mpr hsupport |
| have hmono : μ {z | infDist (normalizedChart Q z) (V : Set (EuclideanSpace ℝ (Fin (n+1)))) ≤ δ} ≤ |
| μ {z | ‖normalizedChart Q z‖ ≤ 2 ∧ infDist (normalizedChart Q z) (V : Set (EuclideanSpace ℝ (Fin (n+1)))) ≤ δ} := by |
| apply measure_mono_ae |
| exact hae.mono fun z hz hzd => ⟨normalizedChart_norm_le hn Q hz, hzd⟩ |
| refine (hmono.trans ht).trans ?_ |
| have hcn : 0 ≤ tubeConstant := le_trans (by norm_num) tubeConstant_ge_one |
| have hg : 0 ≤ gridConstant := gridConstant_nonneg |
| have hq : q ≤ n/2 := by dsimp [q]; omega |
| have hqn : q ≤ n := hq.trans (Nat.div_le_self _ _) |
| have hplane : ((4 * (2 : ℝ) + 5 * δ) / δ)^q ≤ ((13 : ℝ)/δ)^q := by |
| apply pow_le_pow_left₀ (by positivity) |
| apply (div_le_div_iff_of_pos_right hd).mpr |
| linarith |
| have hc : (13 : ℝ)^q * gridConstant^n ≤ tubeConstant^n := by |
| calc |
| _ ≤ (13 : ℝ)^n * (max 1 gridConstant)^n := by |
| exact mul_le_mul (pow_le_pow_right₀ (by norm_num : (1:ℝ) ≤ 13) hqn) |
| (pow_le_pow_left₀ hg (le_max_right 1 gridConstant) n) (pow_nonneg hg _) |
| (by positivity) |
| _ = _ := by rw [← mul_pow]; rfl |
| have hpow : δ^(n/2-q) ≤ δ^e := pow_le_pow_of_le_one hd.le hd1 (by omega) |
| have hcancel : ((13 : ℝ)/δ)^q * δ^(n/2) = (13 : ℝ)^q * δ^(n/2-q) := by |
| rw [pow_sub₀ δ hd.ne' hq, div_pow] |
| ring |
| have hreal : ((4 * (2 : ℝ) + 5 * δ)/δ)^q * gridConstant^n * (B * δ^(n/2)) ≤ |
| B * tubeConstant^n * δ^e := by |
| calc |
| _ ≤ ((13 : ℝ)/δ)^q * gridConstant^n * (B * δ^(n/2)) := by gcongr |
| _ = B * gridConstant^n * (((13 : ℝ)/δ)^q * δ^(n/2)) := by ring |
| _ = B * ((13 : ℝ)^q * gridConstant^n) * δ^(n/2-q) := by rw [hcancel]; ring |
| _ ≤ B * tubeConstant^n * δ^e := by gcongr |
| have hp : 0 ≤ ((4 * (2 : ℝ) + 5 * δ)/δ)^q := by positivity |
| have hpg : 0 ≤ gridConstant^n := pow_nonneg hg _ |
| simp only [show (2:ℝ)+1=3 by norm_num] |
| change ENNReal.ofReal (((4 * (2 : ℝ) + 5 * δ)/δ)^q) * ENNReal.ofReal (gridConstant^n) * |
| ENNReal.ofReal (B * δ^(n/2)) ≤ _ |
| rw [← ENNReal.ofReal_mul hp, ← ENNReal.ofReal_mul (mul_nonneg hp hpg)] |
| convert ENNReal.ofReal_le_ofReal hreal using 1 |
| dsimp [δ] |
| rw [← pow_mul, Nat.mul_comm j e] |
|
|
| end RepeatedLocalization |
|
|
| end OAI |
|
|
