| import OAI.Probability.GaussianRegression.Projection |
| import OAI.Probability.GaussianRegression.Support |
|
|
| namespace OAI |
|
|
| /-! |
| Localization, finite selection, and block mass propagation. |
| -/ |
|
|
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped ENNReal NNReal RealInnerProductSpace Topology |
| open InnerProductSpace |
| open scoped Pointwise |
|
|
| noncomputable section |
|
|
| universe u |
|
|
| namespace NoiselessRegression |
|
|
| section Block |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
|
|
| def PolynomialMass (ν : Measure E) (a : ℕ) (C : ℝ≥0∞) : Prop := |
| ∀ z : E, ∀ r : ℝ, 0 < r → ν (Metric.closedBall z r) ≤ C * ENNReal.ofReal (r^a) |
|
|
| def localNormalize (ν : Measure E) (a : ℕ) (C : ℝ≥0∞) (z : E) (r : ℝ) : Measure E := |
| (C * ENNReal.ofReal (r^a))⁻¹ • (ν.restrict (Metric.closedBall z r)).map (fun x => r⁻¹ • (x-z)) |
|
|
| omit [FiniteDimensional ℝ E] in |
| lemma localNormalize_univ {ν : Measure E} {a : ℕ} {C : ℝ≥0∞} |
| (hν : PolynomialMass ν a C) (hC : C ≠ 0) (hCt : C ≠ ∞) (z : E) {r : ℝ} (hr : 0 < r) : |
| localNormalize ν a C z r univ ≤ 1 := by |
| have hc0 : C * ENNReal.ofReal (r^a) ≠ 0 := mul_ne_zero hC (by positivity) |
| have hct : C * ENNReal.ofReal (r^a) ≠ ∞ := ENNReal.mul_ne_top hCt ENNReal.ofReal_ne_top |
| simp only [localNormalize, Measure.smul_apply, smul_eq_mul, Measure.map_apply (by fun_prop : Measurable (fun x : E => r⁻¹ • (x-z))) MeasurableSet.univ, |
| Set.preimage_univ, Measure.restrict_apply MeasurableSet.univ, Set.univ_inter] |
| exact (mul_le_mul' le_rfl (hν z r hr)).trans_eq (ENNReal.inv_mul_cancel hc0 hct) |
|
|
| omit [FiniteDimensional ℝ E] in |
| lemma localNormalize_finite {ν : Measure E} {a : ℕ} {C : ℝ≥0∞} |
| (hν : PolynomialMass ν a C) (hC : C ≠ 0) (hCt : C ≠ ∞) (z : E) {r : ℝ} (hr : 0 < r) : |
| IsFiniteMeasure (localNormalize ν a C z r) := |
| ⟨(localNormalize_univ hν hC hCt z hr).trans_lt (by simp)⟩ |
|
|
| omit [FiniteDimensional ℝ E] in |
| lemma localNormalize_support (ν : Measure E) (a : ℕ) (C : ℝ≥0∞) (z : E) {r : ℝ} (hr : 0 < r) : |
| (localNormalize ν a C z r).support ⊆ Metric.closedBall 0 1 := by |
| apply Measure.support_subset_of_isClosed Metric.isClosed_closedBall |
| rw [mem_ae_iff, localNormalize, Measure.smul_apply, Measure.map_apply (by fun_prop) |
| Metric.isClosed_closedBall.measurableSet.compl, |
| Measure.restrict_apply ((by fun_prop : Measurable (fun x : E => r⁻¹ • (x-z))) |
| Metric.isClosed_closedBall.measurableSet.compl)] |
| have he : (fun x : E => r⁻¹ • (x-z)) ⁻¹' (Metric.closedBall 0 1)ᶜ ∩ Metric.closedBall z r = ∅ := by |
| apply Set.eq_empty_iff_forall_notMem.mpr |
| intro x ⟨hx,hb⟩ |
| apply hx |
| rw [Metric.mem_closedBall, dist_zero_right, norm_smul, Real.norm_eq_abs, abs_of_pos (inv_pos.mpr hr)] |
| exact (inv_mul_le_iff₀ hr).2 (by simpa [dist_eq_norm] using hb) |
| rw [he, measure_empty, smul_zero] |
|
|
| omit [FiniteDimensional ℝ E] in |
| lemma localNormalize_local {ν : Measure E} {a : ℕ} {C : ℝ≥0∞} |
| (hν : PolynomialMass ν a C) (hC : C ≠ 0) (hCt : C ≠ ∞) (z : E) {r : ℝ} (hr : 0 < r) : |
| HasLocalMassBound (localNormalize ν a C z r) (a : ℝ) := by |
| have hc0 : C * ENNReal.ofReal (r^a) ≠ 0 := mul_ne_zero hC (by positivity) |
| have hct : C * ENNReal.ofReal (r^a) ≠ ∞ := ENNReal.mul_ne_top hCt ENNReal.ofReal_ne_top |
| intro t _ ρ hρ |
| rw [localNormalize, Measure.smul_apply, smul_eq_mul, |
| Measure.map_apply (by fun_prop) Metric.isClosed_closedBall.measurableSet] |
| have hsub : (fun x : E => r⁻¹ • (x-z)) ⁻¹' Metric.closedBall t ρ ⊆ |
| Metric.closedBall (z + r • t) (r*ρ) := by |
| intro x hx |
| have he : x - (z+r • t) = r • (r⁻¹ • (x-z) - t) := by |
| rw [smul_sub, smul_smul, mul_inv_cancel₀ hr.ne', one_smul] |
| abel |
| rw [Metric.mem_closedBall, dist_eq_norm, he, norm_smul, Real.norm_eq_abs, abs_of_pos hr] |
| exact mul_le_mul_of_nonneg_left (by simpa only [Set.mem_preimage, Metric.mem_closedBall, dist_eq_norm] using hx) hr.le |
| calc |
| _ ≤ (C * ENNReal.ofReal (r^a))⁻¹ * ν (Metric.closedBall (z+r • t) (r*ρ)) := |
| mul_le_mul' le_rfl ((Measure.restrict_le_self _).trans (measure_mono hsub)) |
| _ ≤ (C * ENNReal.ofReal (r^a))⁻¹ * (C * ENNReal.ofReal ((r*ρ)^a)) := |
| mul_le_mul' le_rfl (hν _ _ (mul_pos hr hρ)) |
| _ = ENNReal.ofReal (ρ^(a : ℝ)) := by |
| rw [mul_pow, ENNReal.ofReal_mul (pow_nonneg hr.le a), ← mul_assoc C, |
| ← mul_assoc, ENNReal.inv_mul_cancel hc0 hct, one_mul, Real.rpow_natCast] |
|
|
| omit [FiniteDimensional ℝ E] [BorelSpace E] in |
| lemma replicaConstant_le {ν : Measure E} (hν : ν univ ≤ 1) {a m : ℕ} |
| (hd : 1 ≤ Module.finrank ℝ E) (ha : a ≤ Module.finrank ℝ E) (hm : m ≤ Module.finrank ℝ E) : |
| replicaConstant ν (a : ℝ) m ≤ (128 : ℝ≥0∞) ^ Module.finrank ℝ E := by |
| let d := Module.finrank ℝ E |
| have h2 : (2 : ℝ≥0∞) ≤ 2^d := by simpa using pow_le_pow_right₀ (by norm_num : (1 : ℝ≥0∞) ≤ 2) hd |
| have hp : (2 : ℝ≥0∞)^(m+1) ≤ 4^d := by |
| rw [pow_succ] |
| calc |
| _ ≤ (2 : ℝ≥0∞)^d * 2^d := mul_le_mul' (pow_le_pow_right₀ (by norm_num) hm) h2 |
| _ = _ := by rw [← mul_pow]; norm_num |
| calc |
| replicaConstant ν (a : ℝ) m ≤ 1 + (4 : ℝ≥0∞)^d * 4^d * 4^d := by |
| unfold replicaConstant |
| rw [Real.rpow_natCast, ENNReal.ofReal_mul (by positivity), ENNReal.ofReal_pow (by norm_num), |
| ENNReal.ofReal_pow (by norm_num)] |
| norm_num only [ENNReal.ofReal_ofNat] |
| gcongr <;> norm_num |
| _ = 1 + (64 : ℝ≥0∞)^d := by rw [mul_assoc, ← mul_pow, ← mul_pow]; norm_num |
| _ ≤ (2 : ℝ≥0∞) * 64^d := by |
| rw [two_mul] |
| exact add_le_add (one_le_pow₀ (by norm_num)) le_rfl |
| _ ≤ (2 : ℝ≥0∞)^d * 64^d := mul_le_mul' h2 le_rfl |
| _ = _ := by rw [← mul_pow]; norm_num; rfl |
|
|
| lemma projectionLaw_uniform_set_bound {ν : Measure E} [IsFiniteMeasure ν] |
| {a m n : ℕ} (hν : HasLocalMassBound ν (a : ℝ)) (hν1 : ν univ ≤ 1) |
| (hsupport : ν.support ⊆ Metric.closedBall 0 1) |
| (hd : 1 ≤ Module.finrank ℝ E) (ha : a ≤ Module.finrank ℝ E) (hm : m ≤ Module.finrank ℝ E) |
| (hn : 1 ≤ n) (hmargin : n+m ≤ a) (S : Set ((Fin m → E) × (Fin m → ℝ))) : |
| projectionLaw ν m S ≤ (128 : ℝ≥0∞) ^ Module.finrank ℝ E * |
| (matrixLabelReference (E := E) m S)^(1 - 1 / ((n : ℝ)+1)) := by |
| apply (projectionLaw_set_bound hν hsupport m n hn (by exact_mod_cast hmargin) S).trans |
| apply mul_le_mul' _ le_rfl |
| have hn0 : (0 : ℝ) < n+1 := by positivity |
| calc |
| _ ≤ (((128 : ℝ≥0∞)^Module.finrank ℝ E) ^ n)^(1 / ((n : ℝ)+1)) := by |
| apply ENNReal.rpow_le_rpow _ (by positivity) |
| simpa only [one_mul] using mul_le_mul' hν1 (pow_le_pow_left' (replicaConstant_le hν1 hd ha hm) n) |
| _ = ((128 : ℝ≥0∞)^Module.finrank ℝ E)^((n : ℝ)/(n+1)) := by |
| rw [← ENNReal.rpow_natCast, ← ENNReal.rpow_mul] |
| congr 1 |
| rw [mul_one_div] |
| _ ≤ ((128 : ℝ≥0∞)^Module.finrank ℝ E)^(1 : ℝ) := |
| ENNReal.rpow_le_rpow_of_exponent_le (one_le_pow₀ (by norm_num)) |
| ((div_le_one hn0).2 (by linarith)) |
| _ = _ := ENNReal.rpow_one _ |
|
|
| lemma finite_rpow_holder {J : Type*} [Fintype J] (a : J → ℝ≥0∞) {q : ℝ} (hq : 1 < q) : |
| (∑ j, a j ^ (1 - 1/q)) ≤ |
| (Fintype.card J : ℝ≥0∞)^(1/q) * (∑ j, a j)^(1-1/q) := by |
| have hh := Real.HolderConjugate.conjExponent hq |
| have hq' : q.conjExponent ≠ 0 := ne_of_gt hh.symm.pos |
| have hex : 1 - 1/q = q.conjExponent⁻¹ := by simpa only [one_div] using hh.one_sub_inv |
| rw [hex] |
| simpa only [one_mul, one_div, ENNReal.one_rpow, ENNReal.rpow_inv_rpow hq', |
| Finset.sum_const, Finset.card_univ, nsmul_eq_mul, mul_one] using |
| ENNReal.inner_le_Lp_mul_Lq Finset.univ (fun _ : J => (1 : ℝ≥0∞)) |
| (fun j => a j ^ q.conjExponent⁻¹) hh |
|
|
| lemma normalized_routing_bound {J : Type*} [Fintype J] [MeasurableSpace J] |
| [MeasurableSingletonClass J] (ν : J → Measure E) [∀ j, IsFiniteMeasure (ν j)] |
| {a m n : ℕ} (hν : ∀ j, HasLocalMassBound (ν j) (a : ℝ)) |
| (hν1 : ∀ j, ν j univ ≤ 1) (hsupport : ∀ j, (ν j).support ⊆ Metric.closedBall 0 1) |
| (hd : 1 ≤ Module.finrank ℝ E) (ha : a ≤ Module.finrank ℝ E) |
| (hm : m ≤ Module.finrank ℝ E) (hn : 1 ≤ n) (hmargin : n+m ≤ a) |
| (φ : ((Fin m → E) × (Fin m → ℝ)) → J) (hφ : Measurable φ) : |
| (∑ j, projectionLaw (ν j) m {x | φ x = j}) ≤ |
| (32768 : ℝ≥0∞)^Module.finrank ℝ E * (Fintype.card J : ℝ≥0∞)^(1/((n : ℝ)+1)) := by |
| classical |
| obtain ⟨D, hD, hDs, hDV⟩ := exists_projection_support (E := E) m hm |
| let S : J → Set ((Fin m → E) × (Fin m → ℝ)) := fun j => D ∩ {x | φ x = j} |
| have hS (j : J) : MeasurableSet (S j) := hD.inter (hφ (measurableSet_singleton j)) |
| have hSD (j : J) : projectionLaw (ν j) m (S j) = projectionLaw (ν j) m {x | φ x = j} := by |
| apply Measure.measure_inter_eq_of_ae |
| unfold projectionLaw |
| apply (ae_map_iff (by fun_prop) hD).2 |
| filter_upwards [Measure.quasiMeasurePreserving_snd.ae (ν j).support_mem_ae] with x hx |
| exact hDs x.1 x.2 (by simpa using hsupport j hx) |
| have hdis : Pairwise (Function.onFun Disjoint S) := by |
| intro i j hij |
| apply Set.disjoint_left.mpr |
| intro x hi hj |
| exact hij (hi.2.symm.trans hj.2) |
| have hUnion : (⋃ j, S j) = D := by |
| ext x |
| simp only [S, Set.mem_iUnion, Set.mem_inter_iff, Set.mem_ofPred_eq] |
| exact ⟨fun ⟨_,h,_⟩ => h, fun h => ⟨φ x,h,rfl⟩⟩ |
| have hsum : ∑ j, matrixLabelReference (E := E) m (S j) = matrixLabelReference (E := E) m D := by |
| simpa only [hUnion, tsum_fintype] using (measure_iUnion (μ := matrixLabelReference (E := E) m) hdis hS).symm |
| have hα : 0 ≤ 1 - 1/((n : ℝ)+1) := by |
| have : (1 : ℝ) ≤ n := by exact_mod_cast hn |
| nlinarith [one_div_le_one_div_of_le (by norm_num : (0 : ℝ) < 1) (by linarith : (1 : ℝ) ≤ n+1)] |
| have hV : (matrixLabelReference (E := E) m D)^(1-1/((n : ℝ)+1)) ≤ |
| (256 : ℝ≥0∞)^Module.finrank ℝ E := by |
| calc |
| _ ≤ ((256 : ℝ≥0∞)^Module.finrank ℝ E)^(1-1/((n : ℝ)+1)) := |
| ENNReal.rpow_le_rpow (hDV.trans (pow_le_pow_left' (by norm_num) _)) hα |
| _ ≤ ((256 : ℝ≥0∞)^Module.finrank ℝ E)^ (1 : ℝ) := |
| ENNReal.rpow_le_rpow_of_exponent_le (one_le_pow₀ (by norm_num)) (sub_le_self _ (by positivity)) |
| _ = _ := ENNReal.rpow_one _ |
| calc |
| _ = ∑ j, projectionLaw (ν j) m (S j) := by simp_rw [hSD] |
| _ ≤ ∑ j, (128 : ℝ≥0∞)^Module.finrank ℝ E * |
| (matrixLabelReference (E := E) m (S j))^(1-1/((n : ℝ)+1)) := |
| Finset.sum_le_sum fun j _ => projectionLaw_uniform_set_bound |
| (hν j) (hν1 j) (hsupport j) hd ha hm hn hmargin (S j) |
| _ = (128 : ℝ≥0∞)^Module.finrank ℝ E * |
| ∑ j, (matrixLabelReference (E := E) m (S j))^(1-1/((n : ℝ)+1)) := by rw [Finset.mul_sum] |
| _ ≤ (128 : ℝ≥0∞)^Module.finrank ℝ E * |
| ((Fintype.card J : ℝ≥0∞)^(1/((n : ℝ)+1)) * |
| (∑ j, matrixLabelReference (E := E) m (S j))^(1-1/((n : ℝ)+1))) := |
| mul_le_mul' le_rfl (finite_rpow_holder _ (by exact_mod_cast Nat.lt_add_one_of_le hn)) |
| _ ≤ (128 : ℝ≥0∞)^Module.finrank ℝ E * |
| ((Fintype.card J : ℝ≥0∞)^(1/((n : ℝ)+1)) * (256 : ℝ≥0∞)^Module.finrank ℝ E) := by |
| rw [hsum] |
| exact mul_le_mul' le_rfl (mul_le_mul' le_rfl hV) |
| _ = _ := by rw [mul_left_comm, ← mul_pow]; norm_num; rw [mul_comm] |
|
|
| omit [FiniteDimensional ℝ E] in |
| lemma localNormalize_reconstruct (ν : Measure E) (a : ℕ) {C : ℝ≥0∞} |
| (hC : C ≠ 0) (hCt : C ≠ ∞) (z : E) {r : ℝ} (hr : 0 < r) : |
| (C * ENNReal.ofReal (r^a)) • (localNormalize ν a C z r).map (fun t => z+r • t) = |
| ν.restrict (Metric.closedBall z r) := by |
| have hc0 : C * ENNReal.ofReal (r^a) ≠ 0 := mul_ne_zero hC (by positivity) |
| have hct : C * ENNReal.ofReal (r^a) ≠ ∞ := ENNReal.mul_ne_top hCt ENNReal.ofReal_ne_top |
| rw [localNormalize, Measure.map_smul _ (by fun_prop), smul_smul, ENNReal.mul_inv_cancel hc0 hct, |
| one_smul, Measure.map_map (by fun_prop) (by fun_prop)] |
| have he : (fun t : E => z+r • t) ∘ (fun x => r⁻¹ • (x-z)) = id := by |
| ext x |
| simp [smul_smul, hr.ne'] |
| rw [he, Measure.map_id] |
|
|
| lemma projectionLaw_smul (ν : Measure E) [SFinite ν] (m : ℕ) (c : ℝ≥0∞) : |
| projectionLaw (c • ν) m = c • projectionLaw ν m := by |
| rw [projectionLaw, Measure.prod_smul_right, Measure.map_smul _ (by fun_prop)] |
| rfl |
|
|
| lemma projectionLaw_affine (ν : Measure E) [SFinite ν] (m : ℕ) (z : E) (r : ℝ) : |
| projectionLaw (ν.map (fun t => z + r • t)) m = |
| (projectionLaw ν m).map (fun x => (x.1, fun j => ⟪z,x.1 j⟫ + r * x.2 j)) := by |
| unfold projectionLaw |
| rw [← Measure.map_id (μ := Measure.pi (fun _ : Fin m => stdGaussian E)), |
| Measure.map_prod_map _ _ measurable_id (by fun_prop), Measure.map_map (by fun_prop) (by fun_prop), |
| Measure.map_id, Measure.map_map (by fun_prop) (by fun_prop)] |
| congr 1 |
| ext x <;> simp [inner_add_left, real_inner_smul_left] |
|
|
| lemma localized_routing_bound {J : Type*} [Fintype J] [MeasurableSpace J] |
| [MeasurableSingletonClass J] (ν : J → Measure E) [∀ j, IsFiniteMeasure (ν j)] |
| {a m n : ℕ} {C : ℝ≥0∞} (hν : ∀ j, PolynomialMass (ν j) a C) |
| (hC : C ≠ 0) (hCt : C ≠ ∞) |
| (hd : 1 ≤ Module.finrank ℝ E) (ha : a ≤ Module.finrank ℝ E) |
| (hm : m ≤ Module.finrank ℝ E) (hn : 1 ≤ n) (hmargin : n+m ≤ a) |
| (φ : ((Fin m → E) × (Fin m → ℝ)) → J) (hφ : Measurable φ) |
| (z : E) {r : ℝ} (hr : 0 < r) : |
| (∑ j, projectionLaw ((ν j).restrict (Metric.closedBall z r)) m {x | φ x = j}) ≤ |
| (32768 : ℝ≥0∞)^Module.finrank ℝ E * (Fintype.card J : ℝ≥0∞)^(1/((n : ℝ)+1)) * |
| C * ENNReal.ofReal (r^a) := by |
| let τ (j : J) := localNormalize (ν j) a C z r |
| let F : ((Fin m → E) × (Fin m → ℝ)) → ((Fin m → E) × (Fin m → ℝ)) := |
| fun x => (x.1, fun i => ⟪z,x.1 i⟫ + r * x.2 i) |
| have hF : Measurable F := by fun_prop |
| let (j : J) : IsFiniteMeasure (τ j) := localNormalize_finite (hν j) hC hCt z hr |
| have hb := normalized_routing_bound τ |
| (fun j => localNormalize_local (hν j) hC hCt z hr) |
| (fun j => localNormalize_univ (hν j) hC hCt z hr) |
| (fun j => localNormalize_support (ν j) a C z hr) hd ha hm hn hmargin (φ ∘ F) (hφ.comp hF) |
| have he (j : J) : projectionLaw ((ν j).restrict (Metric.closedBall z r)) m {x | φ x = j} = |
| (C * ENNReal.ofReal (r^a)) * projectionLaw (τ j) m {x | φ (F x) = j} := by |
| rw [← localNormalize_reconstruct (ν j) a hC hCt z hr, projectionLaw_smul, |
| projectionLaw_affine, Measure.smul_apply, smul_eq_mul, Measure.map_apply hF |
| (measurableSet_eq_fun hφ measurable_const)] |
| rfl |
| simp_rw [he] |
| rw [← Finset.mul_sum] |
| exact (mul_le_mul' le_rfl hb).trans_eq (by ring) |
|
|
| lemma projectionLaw_withDensity_apply (μ : Measure E) [SFinite μ] {h : E → ℝ≥0∞} |
| (hh : Measurable h) [SFinite (μ.withDensity h)] (m : ℕ) |
| {S : Set ((Fin m → E) × (Fin m → ℝ))} (hS : MeasurableSet S) : |
| projectionLaw (μ.withDensity h) m S = |
| ∫⁻ s, h s * (∫⁻ A, S.indicator (fun _ => (1 : ℝ≥0∞)) (A, fun j => ⟪s,A j⟫) |
| ∂Measure.pi (fun _ : Fin m => stdGaussian E)) ∂μ := by |
| have hobs : Measurable (fun x : (Fin m → E) × E => (x.1, fun j => ⟪x.2,x.1 j⟫)) := by fun_prop |
| have hi : Measurable (fun x : (Fin m → E) × E => S.indicator (fun _ => (1 : ℝ≥0∞)) |
| (x.1, fun j => ⟪x.2,x.1 j⟫)) := |
| ((measurable_const : Measurable (fun _ => (1 : ℝ≥0∞))).indicator hS).comp hobs |
| rw [projectionLaw, Measure.map_apply hobs hS] |
| rw [← one_mul (((Measure.pi (fun _ : Fin m => stdGaussian E)).prod (μ.withDensity h)) _), |
| ← lintegral_indicator_const (hobs hS) 1] |
| change (∫⁻ x : (Fin m → E) × E, S.indicator (fun _ => (1 : ℝ≥0∞)) |
| (x.1, fun j => ⟪x.2,x.1 j⟫) ∂(Measure.pi (fun _ : Fin m => stdGaussian E)).prod (μ.withDensity h)) = _ |
| rw [lintegral_prod_symm _ hi.aemeasurable, |
| lintegral_withDensity_eq_lintegral_mul μ hh hi.lintegral_prod_left] |
| rfl |
|
|
| def blockValue {J : Type*} [Fintype J] {m : ℕ} (h : J → E → ℝ≥0∞) |
| (φ : ((Fin m → E) × (Fin m → ℝ)) → J) (s : E) : ℝ≥0∞ := |
| ∫⁻ A, h (φ (A, fun j => ⟪s,A j⟫)) s ∂Measure.pi (fun _ : Fin m => stdGaussian E) |
|
|
| lemma measurable_finite_select {X J : Type*} [MeasurableSpace X] [Fintype J] |
| [MeasurableSpace J] [MeasurableSingletonClass J] |
| {h : J → X → ℝ≥0∞} (hh : ∀ j, Measurable (h j)) {φ : X → J} (hφ : Measurable φ) : |
| Measurable (fun x => h (φ x) x) := by |
| classical |
| have he (x : X) : h (φ x) x = ∑ j : J, if φ x = j then h j x else 0 := by simp |
| simp_rw [he] |
| exact Finset.measurable_sum _ fun j _ => Measurable.ite |
| (measurableSet_eq_fun hφ measurable_const) (hh j) measurable_const |
|
|
| lemma measurable_blockValue {J : Type*} [Fintype J] [MeasurableSpace J] |
| [MeasurableSingletonClass J] {m : ℕ} {h : J → E → ℝ≥0∞} |
| (hh : ∀ j, Measurable (h j)) {φ : ((Fin m → E) × (Fin m → ℝ)) → J} |
| (hφ : Measurable φ) : Measurable (blockValue h φ) := by |
| apply Measurable.lintegral_prod_left |
| exact measurable_finite_select (fun j => (hh j).comp measurable_snd) |
| (hφ.comp (by fun_prop)) |
|
|
| lemma blockValue_le_one {J : Type*} [Fintype J] {m : ℕ} {h : J → E → ℝ≥0∞} |
| (hh : ∀ j s, h j s ≤ 1) (φ : ((Fin m → E) × (Fin m → ℝ)) → J) (s : E) : |
| blockValue h φ s ≤ 1 := by |
| refine (lintegral_mono (fun A => hh _ s)).trans_eq ?_ |
| simp only [lintegral_const, one_mul, Measure.pi_univ] |
| apply Finset.prod_eq_one |
| intro index _ |
| rw [stdGaussian, Measure.map_apply (by fun_prop) MeasurableSet.univ, Set.preimage_univ] |
| exact measure_univ |
|
|
| lemma blockValue_mass_identity (μ : Measure E) [IsFiniteMeasure μ] |
| {J : Type*} [Fintype J] [MeasurableSpace J] [MeasurableSingletonClass J] |
| {m : ℕ} {h : J → E → ℝ≥0∞} (hh : ∀ j, Measurable (h j)) |
| (hh1 : ∀ j s, h j s ≤ 1) |
| {φ : ((Fin m → E) × (Fin m → ℝ)) → J} (hφ : Measurable φ) |
| {S : Set E} (hS : MeasurableSet S) : |
| (μ.withDensity (blockValue h φ)) S = |
| ∑ j, projectionLaw ((μ.withDensity (h j)).restrict S) m {x | φ x = j} := by |
| classical |
| let g (j : J) (s : E) (A : Fin m → E) : ℝ≥0∞ := |
| if φ (A, fun k => ⟪s,A k⟫) = j then h j s else 0 |
| have hg (j : J) : Measurable (Function.uncurry (g j)) := by |
| exact Measurable.ite (measurableSet_eq_fun (hφ.comp (by fun_prop)) measurable_const) |
| ((hh j).comp measurable_fst) measurable_const |
| have hselect (s : E) (A : Fin m → E) : h (φ (A, fun k => ⟪s,A k⟫)) s = ∑ j, g j s A := by |
| simp [g] |
| have he (j : J) : projectionLaw ((μ.withDensity (h j)).restrict S) m {x | φ x = j} = |
| ∫⁻ s in S, ∫⁻ A, g j s A ∂Measure.pi (fun _ : Fin m => stdGaussian E) ∂μ := by |
| rw [restrict_withDensity hS] |
| let : IsFiniteMeasure ((μ.restrict S).withDensity (h j)) := |
| isFiniteMeasure_withDensity (ne_of_lt ((lintegral_mono (hh1 j)).trans_lt (by simp))) |
| rw [projectionLaw_withDensity_apply _ (hh j) _ (measurableSet_eq_fun hφ measurable_const)] |
| apply lintegral_congr |
| intro s |
| rw [← lintegral_const_mul' _ _ (ne_of_lt ((hh1 j s).trans_lt (by simp)))] |
| apply lintegral_congr |
| intro A |
| by_cases hx : φ (A, fun k => ⟪s,A k⟫) = j <;> simp [g, hx] |
| rw [withDensity_apply _ hS] |
| calc |
| _ = ∫⁻ s in S, ∑ j, ∫⁻ A, g j s A ∂Measure.pi (fun _ : Fin m => stdGaussian E) ∂μ := by |
| apply lintegral_congr |
| intro s |
| unfold blockValue |
| simp_rw [hselect] |
| exact lintegral_finsetSum _ (fun j _ => (hg j).comp (measurable_const.prodMk measurable_id)) |
| _ = _ := by |
| rw [lintegral_finsetSum _ (fun j _ => (hg j).lintegral_prod_right)] |
| simp_rw [he] |
|
|
| lemma blockValue_mass_bound (μ : Measure E) [IsFiniteMeasure μ] |
| {J : Type*} [Fintype J] [MeasurableSpace J] [MeasurableSingletonClass J] |
| {a m n : ℕ} {C : ℝ≥0∞} {h : J → E → ℝ≥0∞} |
| (hh : ∀ j, Measurable (h j)) (hh1 : ∀ j s, h j s ≤ 1) |
| (hlocal : ∀ j, PolynomialMass (μ.withDensity (h j)) a C) |
| (hC : C ≠ 0) (hCt : C ≠ ∞) |
| (hd : 1 ≤ Module.finrank ℝ E) (ha : a ≤ Module.finrank ℝ E) |
| (hm : m ≤ Module.finrank ℝ E) (hn : 1 ≤ n) (hmargin : n+m ≤ a) |
| {φ : ((Fin m → E) × (Fin m → ℝ)) → J} (hφ : Measurable φ) : |
| PolynomialMass (μ.withDensity (blockValue h φ)) a |
| ((32768 : ℝ≥0∞)^Module.finrank ℝ E * (Fintype.card J : ℝ≥0∞)^(1/((n : ℝ)+1)) * C) := by |
| let (j : J) : IsFiniteMeasure (μ.withDensity (h j)) := |
| isFiniteMeasure_withDensity (ne_of_lt ((lintegral_mono (hh1 j)).trans_lt (by simp))) |
| intro z r hr |
| rw [blockValue_mass_identity μ hh hh1 hφ Metric.isClosed_closedBall.measurableSet] |
| exact localized_routing_bound (fun j => μ.withDensity (h j)) hlocal hC hCt hd ha hm hn hmargin φ hφ z hr |
|
|
| end Block |
|
|
| end NoiselessRegression |
|
|
| end |
|
|
| end OAI |
|
|
