| import OAI.Probability.GaussianReplacement.StreamTransfer |
|
|
| namespace OAI |
|
|
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped ENNReal NNReal RealInnerProductSpace Topology |
| noncomputable section |
| universe u |
| namespace NoiselessRegression |
| open InnerProductSpace |
| open scoped Pointwise |
|
|
| namespace Learner |
|
|
| lemma frozen_success_bound {d M T : ℕ} {Ω : Type u} (L : Learner d M T Ω) |
| (ω : Ω) (hd : 3 ≤ d) |
| (htrans : ∀ t j, AEMeasurable (fun obs => (L.transition t ω j obs).2) (observationReference d)) |
| {ε : ℝ} (hε : 0 < ε) {a q : ℕ} (ha : 2*a ≤ d-1) (hq : 2 ≤ q) (hqa : 2*q ≤ a) : |
| ((uniformSphere d).prod (sampleLaw d T)) |
| {z | angularError z.1 (L.estimate z.1 ω z.2) ≤ ε} ≤ |
| (T+1 : ℝ≥0∞) * (ENNReal.ofReal ((3 : ℝ)*4^d) * ENNReal.ofReal (ε^a)) * |
| streamFactor (E := Vector d) (J := State M) q ^ (T/q+1) := by |
| classical |
| let : NeZero d := ⟨by omega⟩ |
| let δ : ℕ → State M → (Vector d × ℝ) → State M := fun t j => (htrans t j).mk _ |
| have hδ (t : ℕ) (j : State M) : Measurable (δ t j) := (htrans t j).measurable_mk |
| let μ := (uniformSphere d).prod (sampleLaw d T) |
| have hgood : ∀ᵐ z ∂μ, ∀ t j (i : Fin T), |
| (L.transition t ω j (z.2 i,⟪z.1.val,z.2 i⟫)).2 = δ t j (z.2 i,⟪z.1.val,z.2 i⟫) := by |
| simp only [ae_all_iff] |
| intro t j i |
| exact (sphere_sample_observation_quasi (by simpa using hd) i).ae (htrans t j).ae_eq_mk |
| let S : Fin (T+1) → Set (UnitSphere d × Samples d T) := fun t => |
| {z | dist z.1.val (L.output t ω (streamRoute δ 0 t (L.initialChoice ω).2 |
| ((fun i => z.2 (Fin.castLE (by omega) i)),fun i => ⟪z.1.val,z.2 (Fin.castLE (by omega) i)⟫))).val ≤ ε} |
| have hmono : {z : UnitSphere d × Samples d T | angularError z.1 (L.estimate z.1 ω z.2) ≤ ε} |
| ≤ᵐ[μ] ⋃ t, S t := by |
| filter_upwards [hgood] with z hz |
| intro hs |
| rcases L.terminal_forced_witness z.1 ω z.2 with ⟨t,ht,he⟩ |
| have hf : L.forcedRun z.1 ω z.2 t = streamRoute δ 0 t (L.initialChoice ω).2 |
| ((fun i => z.2 (Fin.castLE ht i)),fun i => ⟪z.1.val,z.2 (Fin.castLE ht i)⟫) := by |
| rw [L.forcedRun_eq_route z.1 ω z.2 ht] |
| exact streamRoute_congr _ _ 0 t _ _ _ (fun n j i => hz n j (Fin.castLE ht i)) |
| have hc : dist z.1.val (L.estimate z.1 ω z.2).val ≤ ε := by |
| apply le_trans _ hs |
| simpa only [angularError, dist_comm] using chord_le_arccos (L.estimate z.1 ω z.2) z.1 |
| refine Set.mem_iUnion.mpr ⟨⟨t,by omega⟩, ?_⟩ |
| change dist z.1.val (L.output t ω _) ≤ ε |
| simpa only [estimate, he, hf] using hc |
| let B : ℝ≥0∞ := (ENNReal.ofReal ((3 : ℝ)*4^d) * ENNReal.ofReal (ε^a)) * |
| streamFactor (E := Vector d) (J := State M) q ^ (T/q+1) |
| have hb (t : Fin (T+1)) : μ (S t) ≤ B := by |
| simpa only [B, μ, S, uniformSphere, sphereLaw, sampleLaw, finrank_euclideanSpace_fin] using |
| prefix_route_cap_bound hδ (fun j => (L.output t ω j).val) hε |
| (by simpa using ha) hq hqa (by omega : (t : ℕ) ≤ T) (L.initialChoice ω).2 |
| calc |
| _ ≤ μ (⋃ t, S t) := measure_mono_ae hmono |
| _ ≤ ∑' t, μ (S t) := measure_iUnion_le S |
| _ ≤ ∑' _ : Fin (T+1), B := ENNReal.tsum_le_tsum hb |
| _ = _ := by simp [B, tsum_fintype, nsmul_eq_mul, mul_assoc] |
|
|
|
|
| lemma streaming_success_bound {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω] |
| (L : Learner d M T Ω) (ρ : Measure Ω) [IsProbabilityMeasure ρ] |
| (hL : L.Admissible ρ) (hd : 3 ≤ d) {ε : ℝ} (hε : 0 < ε) |
| {a q : ℕ} (ha : 2*a ≤ d-1) (hq : 2 ≤ q) (hqa : 2*q ≤ a) : |
| L.uniformSuccess ρ ε ≤ |
| (T+1 : ℝ≥0∞) * (ENNReal.ofReal ((3 : ℝ)*4^d) * ENNReal.ofReal (ε^a)) * |
| streamFactor (E := Vector d) (J := State M) q ^ (T/q+1) := by |
| let : NeZero d := ⟨by omega⟩ |
| let : SigmaFinite (observationReference d) := by unfold observationReference; infer_instance |
| have hω : ∀ᵐ ω ∂ρ, ∀ t j, |
| AEMeasurable (fun obs => (L.transition t ω j obs).2) (observationReference d) := by |
| simp only [ae_all_iff] |
| intro t j |
| filter_upwards [ae_fiber_aemeasurable (hL.transition t j).prod_swap] with ω hω |
| exact measurable_snd.comp_aemeasurable hω |
| have hp := ((MeasurePreserving.id (uniformSphere d)).prod |
| (Measure.measurePreserving_swap (μ := sampleLaw d T) (ν := ρ))).comp |
| (measurePreserving_prodAssoc (uniformSphere d) (sampleLaw d T) ρ) |
| let S := {z : UnitSphere d × (Ω × Samples d T) | |
| angularError z.1 (L.estimate z.1 z.2.1 z.2.2) ≤ ε} |
| have hS : NullMeasurableSet S ((uniformSphere d).prod (ρ.prod (sampleLaw d T))) := |
| L.angularSuccess_nullMeasurable ρ ε hL |
| have he := hp.measure_preimage hS |
| have hb := prod_null_set_bound (hS.preimage hp.quasiMeasurePreserving) |
| (c := (T+1 : ℝ≥0∞) * (ENNReal.ofReal ((3 : ℝ)*4^d) * ENNReal.ofReal (ε^a)) * |
| streamFactor (E := Vector d) (J := State M) q ^ (T/q+1)) |
| (by |
| filter_upwards [hω] with ω hω |
| exact L.frozen_success_bound ω hd hω hε ha hq hqa) |
| simpa only [he, measure_univ, mul_one, S, uniformSuccess] using hb |
|
|
| end Learner |
|
|
|
|
| end NoiselessRegression |
|
|
| namespace CurrentProjection |
|
|
|
|
| end CurrentProjection |
| namespace NoiselessRegression |
| section ThreeFifthsSphere |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] |
| lemma sphere_projection_large_eighth [Nontrivial E] (U : Submodule ℝ E) |
| (hU : 8 * Module.finrank ℝ U ≤ Module.finrank ℝ E) : |
| sphereLaw {x : Metric.sphere (0 : E) 1 | (4/5 : ℝ) ≤ ‖U.orthogonalProjectionOnto x.val‖^2} ≤ |
| ENNReal.ofReal (5/32 : ℝ) := by |
| have hi := ofReal_integral_eq_lintegral_ofReal (sphere_projection_sq_integrable U) |
| (Filter.Eventually.of_forall fun x => sq_nonneg ‖U.orthogonalProjectionOnto x‖) |
| rw [sphere_projection_sq_integral] at hi |
| have hmark := meas_ge_le_lintegral_div |
| (μ := ambientSphereLaw (E := E)) (f := fun x => ENNReal.ofReal (‖U.orthogonalProjectionOnto x‖^2)) |
| (by fun_prop) (by norm_num : ENNReal.ofReal (4/5 : ℝ) ≠ 0) (ENNReal.ofReal_ne_top : ENNReal.ofReal (4/5 : ℝ) ≠ ∞) |
| rw [← hi] at hmark |
| have hset : {x : E | ENNReal.ofReal (4/5 : ℝ) ≤ ENNReal.ofReal (‖U.orthogonalProjectionOnto x‖^2)} = |
| {x : E | (4/5 : ℝ) ≤ ‖U.orthogonalProjectionOnto x‖^2} := by |
| ext x |
| change ENNReal.ofReal (4/5 : ℝ) ≤ _ ↔ _ |
| exact ENNReal.ofReal_le_ofReal_iff (sq_nonneg _) |
| rw [hset, ambientSphereLaw, |
| (MeasurableEmbedding.subtype_coe Metric.isClosed_sphere.measurableSet).map_apply] at hmark |
| apply hmark.trans |
| have hd : (0 : ℝ) < Module.finrank ℝ E := by |
| exact_mod_cast Module.finrank_pos (R := ℝ) (M := E) |
| have hdiv : (Module.finrank ℝ U : ℝ) / (Module.finrank ℝ E : ℝ) ≤ 1/8 := by |
| rw [div_le_iff₀ hd] |
| have : (8 : ℝ) * Module.finrank ℝ U ≤ Module.finrank ℝ E := by exact_mod_cast hU |
| linarith |
| calc |
| _ ≤ ENNReal.ofReal (1/8 : ℝ) / ENNReal.ofReal (4/5 : ℝ) := by gcongr |
| _ = ENNReal.ofReal (5/32 : ℝ) := by |
| rw [← ENNReal.ofReal_div_of_pos (by norm_num : (0 : ℝ) < 4/5)] |
| norm_num |
|
|
| lemma sphere_reflection_success_bound_eighth [Nontrivial E] (U : Submodule ℝ E) |
| (hU : 8 * Module.finrank ℝ U ≤ Module.finrank ℝ E) |
| (S : Set (Metric.sphere (0 : E) 1)) (hS : NullMeasurableSet S sphereLaw) |
| (hsep : ∀ s ∈ S, sphereIsometry U.reflection s ∈ S → |
| dist s.val (U.reflection s.val) ≤ 1/5) : |
| sphereLaw S ≤ ENNReal.ofReal (37/64 : ℝ) := by |
| let f := sphereIsometry U.reflection |
| have hp := sphereIsometry_preserving U.reflection |
| have hi : S ∩ f ⁻¹' S ⊆ |
| {x : Metric.sphere (0 : E) 1 | (4/5 : ℝ) ≤ ‖U.orthogonalProjectionOnto x.val‖^2} := by |
| intro s hs |
| have hd := hsep s hs.1 hs.2 |
| rw [reflection_dist] at hd |
| have hn := U.norm_sq_eq_add_norm_sq_starProjection s.val |
| rw [mem_sphere_zero_iff_norm.mp s.property] at hn |
| change (4/5 : ℝ) ≤ ‖U.orthogonalProjectionOnto s.val‖^2 |
| have he : ‖U.starProjection s.val‖ = ‖U.orthogonalProjectionOnto s.val‖ := rfl |
| rw [he] at hn |
| nlinarith [norm_nonneg (Uᗮ.starProjection s.val)] |
| have hinter := (measure_mono hi).trans (sphere_projection_large_eighth U hU) |
| have heq := measure_union_add_inter₀ S (hS.preimage hp.quasiMeasurePreserving) |
| rw [hp.measure_preimage hS] at heq |
| calc |
| sphereLaw S = ENNReal.ofReal (1/2 : ℝ) * (sphereLaw S + sphereLaw S) := by |
| rw [← two_mul, ← mul_assoc] |
| have hc : ENNReal.ofReal (1/2 : ℝ) * 2 = 1 := by |
| rw [← ENNReal.ofReal_ofNat, ← ENNReal.ofReal_mul (by norm_num : (0 : ℝ) ≤ 1/2)] |
| norm_num |
| rw [hc, one_mul] |
| _ = ENNReal.ofReal (1/2 : ℝ) * |
| (sphereLaw (S ∪ f ⁻¹' S) + sphereLaw (S ∩ f ⁻¹' S)) := by rw [heq] |
| _ ≤ ENNReal.ofReal (1/2 : ℝ) * (1 + ENNReal.ofReal (5/32 : ℝ)) := by |
| exact mul_le_mul' le_rfl (add_le_add prob_le_one hinter) |
| _ = ENNReal.ofReal (37/64 : ℝ) := by |
| rw [← ENNReal.ofReal_one, ← ENNReal.ofReal_add (by norm_num : (0 : ℝ) ≤ 1) |
| (by norm_num : (0 : ℝ) ≤ 5/32), |
| ← ENNReal.ofReal_mul (by norm_num : (0 : ℝ) ≤ 1/2)] |
| norm_num |
|
|
|
|
| end ThreeFifthsSphere |
| namespace Learner |
| lemma linear_success_bound_three_fifths {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω] |
| (L : Learner d M T Ω) (ρ : Measure Ω) [IsProbabilityMeasure ρ] |
| (hd : 0 < d) (hT : 8*T ≤ d) {ε : ℝ} (hε : ε ≤ 1/10) (hL : L.Admissible ρ) : |
| L.uniformSuccess ρ ε ≤ ENNReal.ofReal (37/64 : ℝ) := by |
| classical |
| let : NeZero d := ⟨hd.ne'⟩ |
| have hmeas := ae_fiber_aemeasurable hL.uniform_experiment |
| unfold uniformSuccess |
| refine (prod_null_set_bound (L.angularSuccess_nullMeasurable ρ ε hL) |
| (c := ENNReal.ofReal (37/64 : ℝ)) ?_).trans_eq (by simp) |
| filter_upwards [hmeas] with z hz |
| let U : Submodule ℝ (Vector d) := Submodule.span ℝ (Set.range z.2) |
| have hdim : Module.finrank ℝ U ≤ T := by |
| have h := finrank_span_le_card (R := ℝ) (Set.range z.2) |
| apply h.trans |
| rw [Set.toFinset_range] |
| exact (Finset.card_image_le).trans_eq (by simp) |
| have hU : 8 * Module.finrank ℝ U ≤ Module.finrank ℝ (Vector d) := by |
| simpa only [Vector, finrank_euclideanSpace_fin] using (Nat.mul_le_mul_left 8 hdim).trans hT |
| change sphereLaw {s : UnitSphere d | angularError s (L.estimate s z.1 z.2) ≤ ε} ≤ _ |
| apply sphere_reflection_success_bound_eighth U hU |
| · exact nullMeasurableSet_le |
| (Real.continuous_arccos.measurable.comp_aemeasurable |
| ((measurable_subtype_coe.comp_aemeasurable hz).inner measurable_subtype_coe.aemeasurable)) |
| aemeasurable_const |
| · intro s hs ht |
| let t := sphereIsometry U.reflection s |
| have he : L.estimate s z.1 z.2 = L.estimate t z.1 z.2 := by |
| apply L.estimate_congr_labels |
| intro i |
| have hi : z.2 i ∈ U := Submodule.subset_span (Set.mem_range_self i) |
| have he := U.reflection.inner_map_map (z.2 i) s.val |
| rw [(Submodule.reflection_eq_self_iff (z.2 i)).2 hi] at he |
| exact he.symm |
| have hs' : dist s.val (L.estimate s z.1 z.2).val ≤ ε := by |
| apply (chord_le_arccos s (L.estimate s z.1 z.2)).trans |
| simpa only [Set.mem_ofPred_eq, angularError, real_inner_comm] using hs |
| have ht' : dist t.val (L.estimate t z.1 z.2).val ≤ ε := by |
| apply (chord_le_arccos t (L.estimate t z.1 z.2)).trans |
| simpa only [Set.mem_ofPred_eq, angularError, real_inner_comm] using ht |
| calc |
| _ = dist s.val t.val := rfl |
| _ ≤ dist s.val (L.estimate s z.1 z.2).val + dist (L.estimate s z.1 z.2).val t.val := dist_triangle _ _ _ |
| _ ≤ ε + ε := by rw [he, dist_comm (L.estimate t z.1 z.2).val t.val] at *; exact add_le_add hs' ht' |
| _ ≤ 1/5 := by linarith |
| |
| end Learner |
| namespace Learner |
| lemma streaming_success_bound_real_three_fifths {d M T : ℕ} {Ω : Type u} [MeasurableSpace Ω] |
| (L : Learner d M T Ω) (ρ : Measure Ω) [IsProbabilityMeasure ρ] |
| (hL : L.Admissible ρ) (hd : 3 ≤ d) {ε : ℝ} (hε : 0 < ε) |
| {a q : ℕ} (ha : 2*a ≤ d-1) (hq : 2 ≤ q) (hqa : 2*q ≤ a) |
| (hs : (3/5 : ℝ≥0∞) ≤ L.uniformSuccess ρ ε) : |
| (3/5 : ℝ) ≤ ((T : ℝ)+1) * ((3 : ℝ)*4^d * ε^a) * |
| ((32768 : ℝ)^d * ((2 : ℝ)^M)^(1/(q : ℝ)))^(T/q+1) := by |
| have hb := hs.trans (L.streaming_success_bound ρ hL hd hε ha hq hqa) |
| have ht : (T+1 : ℝ≥0∞) * |
| (ENNReal.ofReal ((3 : ℝ)*4^d) * ENNReal.ofReal (ε^a)) * |
| streamFactor (E := Vector d) (J := State M) q ^ (T/q+1) ≠ ∞ := by |
| apply ENNReal.mul_ne_top |
| · apply ENNReal.mul_ne_top (by simp) |
| exact ENNReal.mul_ne_top ENNReal.ofReal_ne_top ENNReal.ofReal_ne_top |
| · exact ENNReal.pow_ne_top (streamFactor_ne_top q) |
| have hr := ENNReal.toReal_mono ht hb |
| simpa [ENNReal.toReal_div, ENNReal.toReal_ofNat, ENNReal.toReal_mul, |
| ENNReal.toReal_add, ENNReal.toReal_natCast, ENNReal.toReal_one, |
| ENNReal.toReal_ofReal (by positivity : (0 : ℝ) ≤ 3*4^d), |
| ENNReal.toReal_ofReal (by positivity : 0 ≤ ε^a), streamFactor, |
| ENNReal.toReal_pow, ← ENNReal.toReal_rpow, finrank_euclideanSpace_fin, |
| Fintype.card_fin, State, Nat.cast_pow, Nat.cast_ofNat, Vector] using hr |
| |
| end Learner |
| |
| lemma precision_from_stream_bound_three_fifths {d M T a q : ℕ} {ε A : ℝ} |
| (hd : 32 ≤ d) (hT : d ≤ 8*T) (hq : 0 < q) (hdq : d ≤ 8*q) |
| (ha : d ≤ 4*a) (hM : (M : ℝ) ≤ A * (d : ℝ)^2) (hA : 0 < A) |
| (hε : 0 < ε) (hε1 : ε ≤ 1) |
| (hbound : (3/5 : ℝ) ≤ ((T : ℝ)+1) * ((3 : ℝ)*4^d * ε^a) * |
| ((32768 : ℝ)^d * ((2 : ℝ)^M)^(1/(q : ℝ)))^(T/q+1)) : |
| (1 / (4*(600000+200*A))) * (d : ℝ) * Real.log (1/ε) ≤ (T : ℝ) := by |
| have hd0 : (0 : ℝ) < d := by exact_mod_cast (by omega : 0 < d) |
| have hq0 : (0 : ℝ) < q := by exact_mod_cast hq |
| have hT0 : (0 : ℝ) ≤ T := Nat.cast_nonneg T |
| have hdp : (d : ℝ) ≤ 8*T := by exact_mod_cast hT |
| have hdqp : (d : ℝ) ≤ 8*q := by exact_mod_cast hdq |
| have hap : (d : ℝ) ≤ 4*a := by exact_mod_cast ha |
| have hB : ((T/q+1 : ℕ) : ℝ) * d ≤ 16*T := by |
| have hbd : (T/q+1)*d ≤ 16*T := by |
| have hmul := Nat.div_mul_le_self T q |
| calc |
| (T/q+1)*d = (T/q)*d+d := by ring |
| _ ≤ (T/q)*(8*q)+d := Nat.add_le_add_right (Nat.mul_le_mul_left _ hdq) _ |
| _ = 8*((T/q)*q)+d := by ring |
| _ ≤ 8*T+d := Nat.add_le_add_right (Nat.mul_le_mul_left 8 hmul) _ |
| _ ≤ 16*T := by omega |
| exact_mod_cast hbd |
| have hMq : (M : ℝ) / q ≤ 8*A*d := by |
| apply (div_le_iff₀ hq0).2 |
| calc |
| (M : ℝ) ≤ A*d^2 := hM |
| _ ≤ A*d*(8*q) := by nlinarith [mul_le_mul_of_nonneg_left hdqp (by positivity : 0 ≤ A*d)] |
| _ = 8*A*d*q := by ring |
| have hlog := Real.log_le_log (by norm_num : (0 : ℝ) < 3/5) hbound |
| rw [Real.log_mul (by positivity) (by positivity), |
| Real.log_mul (by positivity) (by positivity), |
| Real.log_mul (by positivity) (by positivity), |
| Real.log_mul (by positivity) (by positivity), |
| Real.log_pow, Real.log_pow, Real.log_pow, |
| Real.log_mul (by positivity) (by positivity), Real.log_pow, |
| Real.log_rpow (by positivity), Real.log_pow] at hlog |
| have hlogε : Real.log (1/ε) = -Real.log ε := by simp |
| have hlogε0 : 0 ≤ Real.log (1/ε) := Real.log_nonneg ((le_div_iff₀ hε).2 (by simpa using hε1)) |
| have heq : (1/(q : ℝ)) * ((M : ℝ)*Real.log 2) = ((M : ℝ)/q)*Real.log 2 := by ring |
| rw [heq] at hlog |
| have hlT : Real.log ((T : ℝ)+1) ≤ T := by |
| simpa using Real.log_le_sub_one_of_pos (by positivity : (0 : ℝ) < T+1) |
| have hl3 : Real.log (3 : ℝ) ≤ 3 := Real.log_le_self (by norm_num) |
| have hl4 : Real.log (4 : ℝ) ≤ 4 := Real.log_le_self (by norm_num) |
| have hl32 : Real.log (32768 : ℝ) ≤ 32768 := Real.log_le_self (by norm_num) |
| have hl2 : Real.log (2 : ℝ) ≤ 1 := by |
| convert Real.log_le_sub_one_of_pos (by norm_num : (0 : ℝ) < 2) using 1; norm_num |
| have hl23 : -(1 : ℝ) ≤ Real.log (3/5 : ℝ) := by |
| have h := Real.one_sub_inv_le_log_of_pos (by norm_num : (0 : ℝ) < 3/5) |
| norm_num at h |
| linarith |
| have hinside : (d : ℝ)*Real.log 32768 + ((M : ℝ)/q)*Real.log 2 ≤ |
| (32768+8*A)*d := by |
| have hm0 : (0 : ℝ) ≤ (M : ℝ)/q := by positivity |
| have h1 := mul_le_mul_of_nonneg_left hl32 hd0.le |
| have h2 := mul_le_mul_of_nonneg_left hl2 hm0 |
| nlinarith |
| have hfull : ((T/q+1 : ℕ) : ℝ) * |
| ((d : ℝ)*Real.log 32768 + ((M : ℝ)/q)*Real.log 2) ≤ |
| 16*T*(32768+8*A) := by |
| calc |
| _ ≤ ((T/q+1 : ℕ) : ℝ) * ((32768+8*A)*d) := |
| mul_le_mul_of_nonneg_left hinside (Nat.cast_nonneg _) |
| _ = (32768+8*A)*(((T/q+1 : ℕ) : ℝ)*d) := by ring |
| _ ≤ (32768+8*A)*(16*T) := mul_le_mul_of_nonneg_left hB (by positivity) |
| _ = _ := by ring |
| have hd4 : (4 : ℝ) ≤ d := by exact_mod_cast (by omega : 4 ≤ d) |
| have hlogbound : (a : ℝ)*Real.log (1/ε) ≤ (600000+200*A)*T := by |
| have h4 := mul_le_mul_of_nonneg_left hl4 hd0.le |
| rw [hlogε] |
| nlinarith [mul_nonneg hA.le hT0] |
| have hmain : (d : ℝ)*Real.log (1/ε) ≤ 4*(600000+200*A)*T := by |
| have ham := mul_le_mul_of_nonneg_right hap hlogε0 |
| linarith |
| have hden : (0 : ℝ) < 4*(600000+200*A) := by positivity |
| calc |
| _ = ((d : ℝ)*Real.log (1/ε))/(4*(600000+200*A)) := by ring |
| _ ≤ T := (div_le_iff₀ hden).2 (by nlinarith [hmain]) |
| |
| |
| end NoiselessRegression |
| |
| end |
| |
| end OAI |
| |
