| import Mathlib |
| import OAI.Probability.Perceptron.Variational.IntegrableProdConditionalSquare |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped ENNReal NNReal Topology BigOperators BoundedContinuousFunction |
|
|
| namespace SphericalPerceptronFreeEnergy |
|
|
| def decoratedLeafIntegral {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (step : X × S → X) (F : X → ℝ≥0∞) : |
| (n : ℕ) → X × DecoratedCascade S n → ℝ≥0∞ |
| | 0, p => F p.1 |
| | n+1, p => ∫⁻ q : ℝ × (S × DecoratedCascade S n), |
| ENNReal.ofReal (Real.exp q.1) * |
| decoratedLeafIntegral step F n (step (p.1,q.2.1),q.2.2) |
| ∂markedStableCountKernel p.2 |
|
|
| lemma decoratedLeafIntegral_exp {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (step : X × S → X) (H : X → ℝ) (n : ℕ) (p : X × DecoratedCascade S n) : |
| decoratedLeafIntegral step (fun x => ENNReal.ofReal (Real.exp (H x))) n p = |
| decoratedTerminalTotalE step H n p := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| simp only [decoratedLeafIntegral, decoratedTerminalTotalE, ih] |
|
|
| lemma decoratedLeafIntegral_measurable {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (step : X × S → X) (hs : Measurable step) (F : X → ℝ≥0∞) |
| (hF : Measurable F) (n : ℕ) : Measurable (decoratedLeafIntegral step F n) := by |
| induction n with |
| | zero => exact hF.comp measurable_fst |
| | succ n ih => |
| have hm : Measurable (fun p : (X × DecoratedCascade S (n+1)) × |
| (ℝ × (S × DecoratedCascade S n)) => |
| ENNReal.ofReal (Real.exp p.2.1) * |
| decoratedLeafIntegral step F n (step (p.1.1,p.2.2.1),p.2.2.2)) := |
| (measurable_snd.fst.exp.ennreal_ofReal).mul |
| (ih.comp ((hs.comp (measurable_fst.fst.prodMk measurable_snd.snd.fst)).prodMk |
| measurable_snd.snd.snd)) |
| exact hm.lintegral_kernel_prod_right' (κ := markedStableCountKernel.prodMkLeft X) |
|
|
| lemma decoratedLeafIntegral_param_measurable {A X S : Type} |
| [MeasurableSpace A] [MeasurableSpace X] [MeasurableSpace S] |
| (step : X × S → X) (hs : Measurable step) (F : A × X → ℝ≥0∞) |
| (hF : Measurable F) (n : ℕ) : |
| Measurable (fun p : A × (X × DecoratedCascade S n) => |
| decoratedLeafIntegral step (fun x => F (p.1,x)) n p.2) := by |
| induction n with |
| | zero => exact hF.comp (measurable_fst.prodMk measurable_snd.fst) |
| | succ n ih => |
| have hm : Measurable (fun p : (A × (X × DecoratedCascade S (n+1))) × |
| (ℝ × (S × DecoratedCascade S n)) => |
| ENNReal.ofReal (Real.exp p.2.1) * |
| decoratedLeafIntegral step (fun x => F (p.1.1,x)) n |
| (step (p.1.2.1,p.2.2.1),p.2.2.2)) := |
| (measurable_snd.fst.exp.ennreal_ofReal).mul |
| (ih.comp (measurable_fst.fst.prodMk |
| ((hs.comp (measurable_fst.snd.fst.prodMk measurable_snd.snd.fst)).prodMk |
| measurable_snd.snd.snd))) |
| exact hm.lintegral_kernel_prod_right' |
| (κ := (markedStableCountKernel.prodMkLeft X).prodMkLeft A) |
|
|
| lemma decoratedLeafIntegral_mono {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (step : X × S → X) {F G : X → ℝ≥0∞} (h : ∀ x, F x ≤ G x) |
| (n : ℕ) (p : X × DecoratedCascade S n) : |
| decoratedLeafIntegral step F n p ≤ decoratedLeafIntegral step G n p := by |
| induction n with |
| | zero => exact h p.1 |
| | succ n ih => |
| exact lintegral_mono fun q => mul_le_mul_right (ih _) _ |
|
|
| lemma decoratedLeafIntegral_const_mul {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (step : X × S → X) (F : X → ℝ≥0∞) (c : ℝ≥0∞) (hc : c ≠ ∞) |
| (n : ℕ) (p : X × DecoratedCascade S n) : |
| decoratedLeafIntegral step (fun x => c * F x) n p = |
| c * decoratedLeafIntegral step F n p := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| simp only [decoratedLeafIntegral, ih, mul_left_comm _ c] |
| exact lintegral_const_mul' _ _ hc |
|
|
| lemma decoratedLeafIntegral_lintegral {A X S : Type} |
| [MeasurableSpace A] [MeasurableSpace X] [MeasurableSpace S] |
| (μ : Measure A) [SFinite μ] (step : X × S → X) (hs : Measurable step) |
| (F : A × X → ℝ≥0∞) (hF : Measurable F) (n : ℕ) |
| (p : X × DecoratedCascade S n) : |
| decoratedLeafIntegral step (fun x => ∫⁻ a, F (a,x) ∂μ) n p = |
| ∫⁻ a, decoratedLeafIntegral step (fun x => F (a,x)) n p ∂μ := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| simp only [decoratedLeafIntegral, ih] |
| have hm : Measurable (fun q : (ℝ × (S × DecoratedCascade S n)) × A => |
| ENNReal.ofReal (Real.exp q.1.1) * |
| decoratedLeafIntegral step (fun x => F (q.2,x)) n |
| (step (p.1,q.1.2.1),q.1.2.2)) := |
| (measurable_fst.fst.exp.ennreal_ofReal).mul |
| ((decoratedLeafIntegral_param_measurable step hs F hF n).comp |
| (measurable_snd.prodMk |
| ((hs.comp (measurable_const.prodMk measurable_fst.snd.fst)).prodMk |
| measurable_fst.snd.snd))) |
| calc |
| _ = ∫⁻ q : ℝ × (S × DecoratedCascade S n), ∫⁻ a, |
| ENNReal.ofReal (Real.exp q.1) * |
| decoratedLeafIntegral step (fun x => F (a,x)) n |
| (step (p.1,q.2.1),q.2.2) ∂μ ∂markedStableCountKernel p.2 := by |
| apply lintegral_congr |
| intro q |
| exact (lintegral_const_mul' _ _ ENNReal.ofReal_ne_top).symm |
| _ = _ := lintegral_lintegral_swap hm.aemeasurable |
|
|
| def decoratedFieldFactor {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (d : ℕ) (step : X × S → X) (field : X → Spin d) (k : ℕ) |
| (p : X × DecoratedCascade S k) (x : Spin d) : ℝ≥0∞ := |
| decoratedLeafIntegral step (fun y => ENNReal.ofReal (Real.exp (inner ℝ (field y) x))) k p |
|
|
| def decoratedAngularFactor {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (n : ℕ) (step : X × S → X) (field : X → Spin (n+1)) (k : ℕ) |
| (p : X × DecoratedCascade S k) (r : ℝ) : ℝ≥0∞ := |
| ∫⁻ u : Metric.sphere (0:Spin (n+1)) 1, |
| decoratedFieldFactor (n+1) step field k p (r • (u:Spin (n+1))) ∂unitSphereLaw (n+1) |
|
|
| lemma decoratedFieldFactor_measurable {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (d : ℕ) (step : X × S → X) (hs : Measurable step) (field : X → Spin d) |
| (hf : Measurable field) (k : ℕ) (p : X × DecoratedCascade S k) : |
| Measurable (decoratedFieldFactor d step field k p) := by |
| let F : Spin d × X → ℝ≥0∞ := fun q => ENNReal.ofReal (Real.exp (inner ℝ (field q.2) q.1)) |
| have hF : Measurable F := |
| (((hf.comp measurable_snd).inner measurable_fst).exp.ennreal_ofReal) |
| have hm : Measurable (fun q : Spin d × (X × DecoratedCascade S k) => |
| decoratedLeafIntegral step (fun y => F (q.1,y)) k q.2) := |
| decoratedLeafIntegral_param_measurable step hs F hF k |
| have hp : Measurable (fun x : Spin d => (x,p)) := measurable_id.prodMk measurable_const |
| change Measurable (fun x : Spin d => decoratedLeafIntegral step (fun y => F (x,y)) k p) |
| have hh := hm.comp hp |
| exact hh |
|
|
| lemma decoratedAngularFactor_eq {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (n : ℕ) (step : X × S → X) (hs : Measurable step) (field : X → Spin (n+1)) |
| (hf : Measurable field) (k : ℕ) (p : X × DecoratedCascade S k) (r : ℝ) : |
| decoratedAngularFactor n step field k p r = |
| decoratedLeafIntegral step (fun y => ENNReal.ofReal (sphericalExp n (field y) r)) k p := by |
| have h := decoratedLeafIntegral_lintegral (unitSphereLaw (n+1)) step hs |
| (fun q : (Metric.sphere (0:Spin (n+1)) 1) × X => |
| ENNReal.ofReal (Real.exp (inner ℝ (field q.2) (r • (q.1:Spin (n+1)))))) |
| (((hf.comp measurable_snd).inner (measurable_fst.subtype_coe.const_smul r)).exp.ennreal_ofReal) |
| k p |
| change (∫⁻ a : Metric.sphere (0:Spin (n+1)) 1, |
| decoratedLeafIntegral step (fun y => ENNReal.ofReal (Real.exp (inner ℝ (field y) (r • (a:Spin (n+1)))))) k p |
| ∂unitSphereLaw (n+1)) = _ |
| rw [← h] |
| congr 1 |
| funext y |
| simp only [inner_smul_right] |
| exact (ofReal_integral_eq_lintegral_ofReal |
| (unitSphere_continuous_integrable (by fun_prop)) |
| (Eventually.of_forall fun u => (Real.exp_pos _).le)).symm |
|
|
| lemma decoratedAngularFactor_mono {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (n : ℕ) (step : X × S → X) (hs : Measurable step) (field : X → Spin (n+1)) |
| (hf : Measurable field) (k : ℕ) (p : X × DecoratedCascade S k) |
| {r s : ℝ} (hr : 0 ≤ r) (hrs : r ≤ s) : |
| decoratedAngularFactor n step field k p r ≤ decoratedAngularFactor n step field k p s := by |
| rw [decoratedAngularFactor_eq n step hs field hf, decoratedAngularFactor_eq n step hs field hf] |
| exact decoratedLeafIntegral_mono step |
| (fun y => ENNReal.ofReal_le_ofReal (sphericalExp_mono n (field y) hr hrs)) k p |
|
|
| lemma decoratedAngularFactor_mass_le {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (n : ℕ) (step : X × S → X) (hs : Measurable step) (field : X → Spin (n+1)) |
| (hf : Measurable field) (k : ℕ) (p : X × DecoratedCascade S k) (r : ℝ) : |
| decoratedTerminalTotalE step (fun _ => 0) k p ≤ decoratedAngularFactor n step field k p r := by |
| rw [decoratedAngularFactor_eq n step hs field hf, ← decoratedLeafIntegral_exp] |
| apply decoratedLeafIntegral_mono |
| intro y |
| simpa using ENNReal.ofReal_le_ofReal (one_le_sphericalExp n (field y) r) |
|
|
| theorem decoratedCanonical_band_bounds {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (n : ℕ) (step : X × S → X) (hs : Measurable step) (field : X → Spin (n+1)) |
| (hf : Measurable field) (k : ℕ) (p : X × DecoratedCascade S k) (b ε : ℝ) : |
| decoratedAngularFactor n step field k p (Real.sqrt (((n+1:ℕ):ℝ)*(1-ε))) * |
| canonicalRadialMass n b (normSquareBand n ε) ≤ |
| (∫⁻ x in normSquareBand n ε, |
| decoratedFieldFactor (n+1) step field k p x ∂canonicalRadialMass n b) ∧ |
| (∫⁻ x in normSquareBand n ε, |
| decoratedFieldFactor (n+1) step field k p x ∂canonicalRadialMass n b) ≤ |
| decoratedAngularFactor n step field k p (Real.sqrt (((n+1:ℕ):ℝ)*(1+ε))) * |
| canonicalRadialMass n b (normSquareBand n ε) := by |
| have hm := decoratedFieldFactor_measurable (n+1) step hs field hf k p |
| have hh := polar_weighted_bounds (volume : Measure (RadialSpace n)) |
| (decoratedFieldFactor (n+1) step field k p) hm |
| (canonicalBandRadiusWeight n b ε) (canonicalBandRadiusWeight_measurable n b ε) |
| (L := decoratedAngularFactor n step field k p (Real.sqrt (((n+1:ℕ):ℝ)*(1-ε)))) |
| (U := decoratedAngularFactor n step field k p (Real.sqrt (((n+1:ℕ):ℝ)*(1+ε)))) |
| rw [canonicalBandRadiusWeight_integral n b ε _ hm,canonicalBandRadiusWeight_mass] at hh |
| apply hh |
| · intro r hr |
| have hb : ((n+1:ℕ):ℝ)*(1-ε) ≤ (r:ℝ)^2 ∧ (r:ℝ)^2 ≤ ((n+1:ℕ):ℝ)*(1+ε) := by |
| by_contra hn |
| exact hr (by simp only [canonicalBandRadiusWeight,Set.indicator_apply,Set.mem_ofPred_eq,hn,ite_false]) |
| change _ ≤ decoratedAngularFactor n step field k p r |
| apply decoratedAngularFactor_mono n step hs field hf k p (Real.sqrt_nonneg _) |
| exact (Real.sqrt_le_iff).mpr ⟨r.property.le,hb.1⟩ |
| · intro r hr |
| have hb : ((n+1:ℕ):ℝ)*(1-ε) ≤ (r:ℝ)^2 ∧ (r:ℝ)^2 ≤ ((n+1:ℕ):ℝ)*(1+ε) := by |
| by_contra hn |
| exact hr (by simp only [canonicalBandRadiusWeight,Set.indicator_apply,Set.mem_ofPred_eq,hn,ite_false]) |
| change decoratedAngularFactor n step field k p r ≤ _ |
| apply decoratedAngularFactor_mono n step hs field hf k p r.property.le |
| exact (Real.le_sqrt' r.property).mpr hb.2 |
|
|
| lemma canonicalRadialDensity_complete_square (n : ℕ) {b : ℝ} (hb : 0 < b) |
| (z x : Spin (n+1)) : |
| canonicalRadialDensity n b x * Real.exp (inner ℝ z x) = |
| Real.exp (‖z‖^2/(2*b)) * canonicalRadialDensity n b (x - b⁻¹ • z) := by |
| have he : -(b/2)*‖x‖^2 + inner ℝ z x = ‖z‖^2/(2*b) - (b/2)*‖x-b⁻¹ • z‖^2 := by |
| rw [norm_sub_sq_real,inner_smul_right,norm_smul,Real.norm_eq_abs, |
| abs_of_pos (inv_pos.mpr hb),mul_pow,real_inner_comm x z] |
| field_simp |
| ring |
| unfold canonicalRadialDensity |
| calc |
| _ = radialNormalizer n * Real.exp (-(b/2)*‖x‖^2 + inner ℝ z x) := by rw [Real.exp_add]; ring |
| _ = _ := by rw [he,Real.exp_sub,neg_mul,Real.exp_neg]; ring |
|
|
| lemma canonicalRadial_linear_integral (n : ℕ) {b : ℝ} (hb : 0 < b) |
| (z : Spin (n+1)) : |
| (∫⁻ x, ENNReal.ofReal (Real.exp (inner ℝ z x)) ∂canonicalRadialMass n b) = |
| ENNReal.ofReal (Real.exp (-((n+1:ℕ):ℝ)*Real.log b/2 + ‖z‖^2/(2*b))) := by |
| rw [canonicalRadialMass,lintegral_withDensity_eq_lintegral_mul _ |
| (canonicalRadialDensity_continuous n b).measurable.ennreal_ofReal (by fun_prop)] |
| simp only [Pi.mul_apply,← ENNReal.ofReal_mul (canonicalRadialDensity_pos n b _).le, |
| canonicalRadialDensity_complete_square n hb] |
| simp_rw [ENNReal.ofReal_mul (Real.exp_pos _).le] |
| rw [lintegral_const_mul' _ _ ENNReal.ofReal_ne_top] |
| rw [lintegral_sub_right_eq_self (fun x => ENNReal.ofReal (canonicalRadialDensity n b x)) (b⁻¹ • z)] |
| rw [← ofReal_integral_eq_lintegral_ofReal (canonicalRadialDensity_integrable n hb) |
| (Eventually.of_forall fun x => (canonicalRadialDensity_pos n b x).le), |
| canonicalRadialDensity_integral n hb,← ENNReal.ofReal_mul (Real.exp_pos _).le, |
| Real.rpow_def_of_pos hb,← Real.exp_add] |
| congr 2 |
| ring |
|
|
| def coordinateLeafField (d : ℕ) (x : Fin d → ℕ → ℝ) : Spin d := |
| WithLp.toLp 2 (fun i => x i 0) |
|
|
| lemma coordinateLeafField_measurable (d : ℕ) : Measurable (coordinateLeafField d) := by |
| apply (MeasurableEquiv.toLp 2 (Fin d → ℝ)).measurable.comp |
| apply Measurable.of_eval |
| intro i |
| exact (measurable_pi_apply 0).comp (measurable_pi_apply i) |
|
|
| lemma coordinateLeafField_norm_sq (d : ℕ) (x : Fin d → ℕ → ℝ) : |
| ‖coordinateLeafField d x‖^2 = ∑ i, (x i 0)^2 := by |
| rw [EuclideanSpace.norm_sq_eq] |
| simp only [coordinateLeafField,WithLp.ofLp_toLp,Real.norm_eq_abs,sq_abs] |
|
|
| lemma canonicalCoordinatePotential_eq_norm (d : ℕ) (b : ℝ) (x : Fin d → ℕ → ℝ) : |
| canonicalCoordinatePotential d b x = - (d:ℝ)*Real.log b/2 + ‖coordinateLeafField d x‖^2/(2*b) := by |
| rw [coordinateLeafField_norm_sq] |
| simp only [canonicalCoordinatePotential,Finset.sum_add_distrib,Finset.sum_const, |
| Finset.card_univ,Fintype.card_fin,nsmul_eq_mul,Finset.sum_div] |
| ring |
|
|
| theorem canonicalCoordinateTotalE_eq_radial (n k : ℕ) (σ : ℕ → ℝ) {b : ℝ} (hb : 0 < b) |
| (p : (Fin (n+1) → ℕ → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k) : |
| decoratedTerminalTotalE (canonicalCoordinateStep (n+1) σ) |
| (canonicalCoordinatePotential (n+1) b) k p = |
| ∫⁻ x, decoratedFieldFactor (n+1) (canonicalCoordinateStep (n+1) σ) |
| (coordinateLeafField (n+1)) k p x ∂canonicalRadialMass n b := by |
| let : SFinite (canonicalRadialMass n b) := by |
| unfold canonicalRadialMass |
| infer_instance |
| have hf : Measurable (fun q : Spin (n+1) × (Fin (n+1) → ℕ → ℝ) => |
| ENNReal.ofReal (Real.exp (inner ℝ (coordinateLeafField (n+1) q.2) q.1))) := |
| (((coordinateLeafField_measurable (n+1)).comp measurable_snd).inner measurable_fst).exp.ennreal_ofReal |
| have h := decoratedLeafIntegral_lintegral (canonicalRadialMass n b) |
| (canonicalCoordinateStep (n+1) σ) (canonicalCoordinateStep_measurable (n+1) σ) _ hf k p |
| change _ = ∫⁻ x, decoratedLeafIntegral (canonicalCoordinateStep (n+1) σ) |
| (fun y => ENNReal.ofReal (Real.exp (inner ℝ (coordinateLeafField (n+1) y) x))) k p |
| ∂canonicalRadialMass n b |
| rw [← h, ← decoratedLeafIntegral_exp] |
| congr 1 |
| funext y |
| change _ = ∫⁻ a, ENNReal.ofReal (Real.exp (inner ℝ (coordinateLeafField (n+1) y) a)) ∂canonicalRadialMass n b |
| rw [canonicalRadial_linear_integral n hb,canonicalCoordinatePotential_eq_norm] |
|
|
| def sphericalCoordinateLog (n k : ℕ) (σ : ℕ → ℝ) (v : ℝ) |
| (p : (Fin (n+1) → ℕ → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k) : ℝ := |
| Real.log ((decoratedAngularFactor n (canonicalCoordinateStep (n+1) σ) |
| (coordinateLeafField (n+1)) k p (Real.sqrt (((n+1:ℕ):ℝ)*v))).toReal / |
| decoratedTerminalTotal (canonicalCoordinateStep (n+1) σ) (fun _ => 0) k p) |
|
|
| lemma canonicalCoordinateLog_eq_radial (n k : ℕ) (σ : ℕ → ℝ) {b : ℝ} (hb : 0 < b) |
| (p : (Fin (n+1) → ℕ → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k) : |
| canonicalCoordinateLog (n+1) k σ b p = |
| Real.log ((∫⁻ x, decoratedFieldFactor (n+1) (canonicalCoordinateStep (n+1) σ) |
| (coordinateLeafField (n+1)) k p x ∂canonicalRadialMass n b).toReal / |
| decoratedTerminalTotal (canonicalCoordinateStep (n+1) σ) (fun _ => 0) k p) := by |
| unfold canonicalCoordinateLog decoratedTerminalTotal |
| rw [canonicalCoordinateTotalE_eq_radial n k σ hb] |
|
|
| lemma decoratedLeafIntegral_holder {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (step : X × S → X) (hs : Measurable step) {F G : X → ℝ≥0∞} |
| (hF : Measurable F) (hG : Measurable G) {a b : ℝ} |
| (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a+b=1) (k : ℕ) |
| (p : X × DecoratedCascade S k) : |
| decoratedLeafIntegral step (fun x => F x ^ a * G x ^ b) k p ≤ |
| decoratedLeafIntegral step F k p ^ a * decoratedLeafIntegral step G k p ^ b := by |
| induction k with |
| | zero => exact le_rfl |
| | succ k ih => |
| let H : (ℝ × (S × DecoratedCascade S k)) → X × DecoratedCascade S k := |
| fun q => (step (p.1,q.2.1),q.2.2) |
| have hH : Measurable H := |
| (hs.comp (measurable_const.prodMk measurable_snd.fst)).prodMk measurable_snd.snd |
| have hFm : Measurable (fun q => ENNReal.ofReal (Real.exp q.1) * |
| decoratedLeafIntegral step F k (H q)) := |
| (measurable_fst.exp.ennreal_ofReal).mul |
| ((decoratedLeafIntegral_measurable step hs F hF k).comp hH) |
| have hGm : Measurable (fun q => ENNReal.ofReal (Real.exp q.1) * |
| decoratedLeafIntegral step G k (H q)) := |
| (measurable_fst.exp.ennreal_ofReal).mul |
| ((decoratedLeafIntegral_measurable step hs G hG k).comp hH) |
| change (∫⁻ q, ENNReal.ofReal (Real.exp q.1) * |
| decoratedLeafIntegral step (fun x => F x ^ a * G x ^ b) k (H q) |
| ∂markedStableCountKernel p.2) ≤ _ |
| refine le_trans (lintegral_mono fun q => mul_le_mul_right (ih (H q)) _) ?_ |
| calc |
| _ = ∫⁻ q, (ENNReal.ofReal (Real.exp q.1) * decoratedLeafIntegral step F k (H q)) ^ a * |
| (ENNReal.ofReal (Real.exp q.1) * decoratedLeafIntegral step G k (H q)) ^ b |
| ∂markedStableCountKernel p.2 := by |
| congr 1 |
| funext q |
| rw [ENNReal.mul_rpow_of_nonneg _ _ ha,ENNReal.mul_rpow_of_nonneg _ _ hb] |
| have he : ENNReal.ofReal (Real.exp q.1) ^ a * ENNReal.ofReal (Real.exp q.1) ^ b = |
| ENNReal.ofReal (Real.exp q.1) := by |
| rw [← ENNReal.rpow_add _ _ (by simp [Real.exp_pos]) ENNReal.ofReal_ne_top,hab,ENNReal.rpow_one] |
| calc |
| _ = (ENNReal.ofReal (Real.exp q.1) ^ a * ENNReal.ofReal (Real.exp q.1) ^ b) * |
| (decoratedLeafIntegral step F k (H q) ^ a * decoratedLeafIntegral step G k (H q) ^ b) := by rw [he] |
| _ = _ := by ring |
| _ ≤ _ := ENNReal.lintegral_mul_norm_pow_le hFm.aemeasurable hGm.aemeasurable ha hb hab |
|
|
| lemma ofReal_exp_affine (x y a b : ℝ) : |
| ENNReal.ofReal (Real.exp (a*x+b*y)) = |
| ENNReal.ofReal (Real.exp x) ^ a * ENNReal.ofReal (Real.exp y) ^ b := by |
| rw [Real.exp_add, ENNReal.ofReal_mul (Real.exp_pos _).le] |
| congr 1 <;> rw [ENNReal.ofReal_rpow_of_pos (Real.exp_pos _),Real.rpow_def_of_pos (Real.exp_pos _),Real.log_exp] <;> congr 1 <;> ring_nf |
|
|
| lemma sphericalExp_holder (n : ℕ) (z : Spin (n+1)) (r s : ℝ) {a b : ℝ} |
| (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a+b=1) : |
| ENNReal.ofReal (sphericalExp n z (a*r+b*s)) ≤ |
| ENNReal.ofReal (sphericalExp n z r)^a * ENNReal.ofReal (sphericalExp n z s)^b := by |
| have he (t : ℝ) : ENNReal.ofReal (sphericalExp n z t) = |
| ∫⁻ x : Metric.sphere (0 : Spin (n+1)) 1, |
| ENNReal.ofReal (Real.exp (inner ℝ z (t • x.val))) ∂unitSphereLaw (n+1) := by |
| simp only [inner_smul_right] |
| exact ofReal_integral_eq_lintegral_ofReal |
| (unitSphere_continuous_integrable (by fun_prop)) |
| (ae_of_all _ fun _ => (Real.exp_pos _).le) |
| simp_rw [he] |
| have h (x : Metric.sphere (0 : Spin (n+1)) 1) : |
| ENNReal.ofReal (Real.exp (inner ℝ z ((a*r+b*s) • x.val))) = |
| ENNReal.ofReal (Real.exp (inner ℝ z (r • x.val)))^a * |
| ENNReal.ofReal (Real.exp (inner ℝ z (s • x.val)))^b := by |
| simp only [inner_smul_right] |
| rw [show (a*r+b*s)*inner ℝ z x.val = a*(r*inner ℝ z x.val)+b*(s*inner ℝ z x.val) by ring] |
| exact ofReal_exp_affine _ _ _ _ |
| simp_rw [h] |
| exact ENNReal.lintegral_mul_norm_pow_le (by fun_prop) (by fun_prop) ha hb hab |
|
|
| lemma decoratedAngularFactor_holder {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| (n : ℕ) (step : X × S → X) (hs : Measurable step) |
| (z : X → Spin (n+1)) (hz : Measurable z) (k : ℕ) (p : X × DecoratedCascade S k) |
| (r s : ℝ) {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a+b=1) : |
| decoratedAngularFactor n step z k p (a*r+b*s) ≤ |
| decoratedAngularFactor n step z k p r ^ a * decoratedAngularFactor n step z k p s ^ b := by |
| simp_rw [decoratedAngularFactor_eq n step hs z hz] |
| refine (decoratedLeafIntegral_mono step (fun x => sphericalExp_holder n (z x) r s ha hb hab) k p).trans ?_ |
| apply decoratedLeafIntegral_holder step hs _ _ ha hb hab |
| all_goals |
| unfold sphericalExp |
| apply ENNReal.measurable_ofReal.comp |
| exact (show StronglyMeasurable (fun p : X × Metric.sphere (0:Spin (n+1)) 1 => |
| Real.exp (_ * inner ℝ (z p.1) (p.2:Spin (n+1)))) from (by fun_prop)).integral_prod_right'.measurable |
|
|
| lemma decoratedTerminalTotal_pos_of_fractional {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| [Nonempty S] (ν : ProbabilityMeasure S) (step : X × S → X) (hs : Measurable step) |
| (H : X → ℝ) (hH : Measurable H) (k : ℕ) (z : Fin k → ℝ) |
| (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1) |
| (hI : finiteCascadeFractionalIntegrable ν step H k z) (x : X) : |
| ∀ᵐ η ∂(decoratedCascadeLaw ν k z : Measure (DecoratedCascade S k)), |
| 0 < decoratedTerminalTotal step H k (x,η) := by |
| have hid := decoratedWeightedTotal_identDistrib ν step hs k z hz0 hz1 |
| (finiteCascadeShifts ν step k z H) (finiteCascadeShifts_measurable ν step hs k z hH) |
| (fun i y => (finiteCascadeShifts_normalized_of_fractional ν step k z |
| (fun j => (hz0 j).ne') H hI i y).1) |
| (fun i y => (finiteCascadeShifts_normalized_of_fractional ν step k z |
| (fun j => (hz0 j).ne') H hI i y).2) x |
| have hp := hid.symm.ae_snd measurableSet_Ioi (cascadeTotal_regular k z hz hz0 hz1).1 |
| filter_upwards [hp] with η hη |
| rw [decoratedTerminalTotal_telescoping ν step H k z] |
| exact mul_pos (Real.exp_pos _) hη |
|
|
| lemma decoratedTerminalTotal_zero_pos {X S : Type} [MeasurableSpace X] [MeasurableSpace S] |
| [Nonempty S] (ν : ProbabilityMeasure S) (step : X × S → X) (hs : Measurable step) |
| (k : ℕ) (z : Fin k → ℝ) (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1) |
| (x : X) : |
| ∀ᵐ η ∂(decoratedCascadeLaw ν k z : Measure (DecoratedCascade S k)), |
| 0 < decoratedTerminalTotal step (fun _ => 0) k (x,η) := by |
| have hid := decoratedWeightedTotal_identDistrib ν step hs k z hz0 hz1 (fun _ _ => 0) |
| (fun _ => measurable_const) (by intro i y; simp only [mul_zero,Real.exp_zero]; exact integrable_const 1) |
| (by intro i y; simp) x |
| simpa only [decoratedTerminalTotal_zero] using |
| hid.symm.ae_snd measurableSet_Ioi (cascadeTotal_regular k z hz hz0 hz1).1 |
|
|
| def coordinateCascadeLaw (d k : ℕ) (z : Fin k → ℝ) (r : ℝ≥0) : |
| Measure ((Fin d → ℝ) × DecoratedCascade (Fin d → ℝ) k) := |
| (Measure.pi (fun _ : Fin d => gaussianReal 0 r)).prod |
| (decoratedCascadeLaw (piMarkLaw (fun _ : Fin d => standardGaussianMark)) k z) |
|
|
| instance coordinateCascadeLaw_probability (d k : ℕ) (z : Fin k → ℝ) (r : ℝ≥0) : |
| IsProbabilityMeasure (coordinateCascadeLaw d k z r) := by |
| unfold coordinateCascadeLaw |
| infer_instance |
|
|
| lemma canonicalCoordinateTotal_pos (d k : ℕ) (σ : ℕ → ℝ) (b : ℝ) (z : Fin k → ℝ) |
| (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1) |
| (hp : 0 < quadraticCascadePrecision σ b k z) (r : ℝ≥0) : |
| ∀ᵐ p ∂coordinateCascadeLaw d k z r, |
| 0 < decoratedTerminalTotal (canonicalCoordinateStep d σ) |
| (canonicalCoordinatePotential d b) k ((fun i _ => p.1 i),p.2) := by |
| have hm : Measurable (fun p : (Fin d → ℝ) × DecoratedCascade (Fin d → ℝ) k => |
| decoratedTerminalTotal (canonicalCoordinateStep d σ) (canonicalCoordinatePotential d b) k |
| ((fun i _ => p.1 i),p.2)) := |
| (decoratedTerminalTotal_measurable (piMarkLaw (fun _ : Fin d => standardGaussianMark)) _ (canonicalCoordinateStep_measurable d σ) |
| (canonicalCoordinatePotential_measurable d b) k z).comp |
| (show Measurable (fun p : (Fin d → ℝ) × DecoratedCascade (Fin d → ℝ) k => |
| ((fun (i : Fin d) (_ : ℕ) => p.1 i),p.2)) from by fun_prop) |
| apply (Measure.ae_prod_iff_ae_ae (measurableSet_lt measurable_const hm)).mpr |
| exact ae_of_all _ fun x => decoratedTerminalTotal_pos_of_fractional |
| (piMarkLaw (fun _ : Fin d => standardGaussianMark)) (canonicalCoordinateStep d σ) |
| (canonicalCoordinateStep_measurable d σ) _ (canonicalCoordinatePotential_measurable d b) |
| k z hz hz0 hz1 (canonical_coordinate_recursion d σ b k z hz0 hp).2 (fun i _ => x i) |
|
|
| lemma canonicalCoordinateBase_pos (d k : ℕ) (σ : ℕ → ℝ) (z : Fin k → ℝ) |
| (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1) (r : ℝ≥0) : |
| ∀ᵐ p ∂coordinateCascadeLaw d k z r, |
| 0 < decoratedTerminalTotal (canonicalCoordinateStep d σ) |
| (fun _ => 0) k ((fun i _ => p.1 i),p.2) := by |
| have hm : Measurable (fun p : (Fin d → ℝ) × DecoratedCascade (Fin d → ℝ) k => |
| decoratedTerminalTotal (canonicalCoordinateStep d σ) (fun _ => 0) k |
| ((fun i _ => p.1 i),p.2)) := |
| (decoratedTerminalTotal_measurable (piMarkLaw (fun _ : Fin d => standardGaussianMark)) _ (canonicalCoordinateStep_measurable d σ) |
| measurable_const k z).comp |
| (show Measurable (fun p : (Fin d → ℝ) × DecoratedCascade (Fin d → ℝ) k => |
| ((fun (i : Fin d) (_ : ℕ) => p.1 i),p.2)) from by fun_prop) |
| apply (Measure.ae_prod_iff_ae_ae (measurableSet_lt measurable_const hm)).mpr |
| exact ae_of_all _ fun x => decoratedTerminalTotal_zero_pos |
| (piMarkLaw (fun _ : Fin d => standardGaussianMark)) (canonicalCoordinateStep d σ) |
| (canonicalCoordinateStep_measurable d σ) k z hz hz0 hz1 (fun i _ => x i) |
|
|
| lemma sphericalExp_le_gaussian (n : ℕ) (z : Spin (n+1)) (R : ℝ) {b : ℝ} (hb : 0 < b) : |
| sphericalExp n z R ≤ Real.exp (‖z‖^2/(2*b)+b*R^2/2) := by |
| have h (u : Metric.sphere (0 : Spin (n+1)) 1) : |
| R * inner ℝ z (u : Spin (n+1)) ≤ ‖z‖^2/(2*b)+b*R^2/2 := by |
| have hn : ‖(u : Spin (n+1))‖ = 1 := by simp |
| have hh := sq_nonneg ‖z - (b*R) • (u : Spin (n+1))‖ |
| rw [norm_sub_sq_real,inner_smul_right,norm_smul,hn,Real.norm_eq_abs,mul_one,sq_abs] at hh |
| calc |
| _ ≤ (‖z‖^2+(b*R)^2)/(2*b) := |
| (le_div_iff₀ (by positivity : 0 < 2*b)).mpr (by nlinarith [hh]) |
| _ = _ := by field_simp |
| unfold sphericalExp |
| calc |
| _ ≤ ∫ _ : Metric.sphere (0 : Spin (n+1)) 1, |
| Real.exp (‖z‖^2/(2*b)+b*R^2/2) ∂unitSphereLaw (n+1) := |
| integral_mono (unitSphere_continuous_integrable (by fun_prop)) (integrable_const _) |
| (fun u => Real.exp_le_exp.mpr (h u)) |
| _ = _ := by simp |
|
|
| lemma decoratedAngularFactor_le_canonical (n k : ℕ) (σ : ℕ → ℝ) (R : ℝ) {b : ℝ} (hb : 0 < b) |
| (p : (Fin (n+1) → ℕ → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k) : |
| decoratedAngularFactor n (canonicalCoordinateStep (n+1) σ) (coordinateLeafField (n+1)) k p R ≤ |
| ENNReal.ofReal (Real.exp (((n+1:ℕ):ℝ)*Real.log b/2+b*R^2/2)) * |
| decoratedTerminalTotalE (canonicalCoordinateStep (n+1) σ) (canonicalCoordinatePotential (n+1) b) k p := by |
| rw [decoratedAngularFactor_eq n _ (canonicalCoordinateStep_measurable (n+1) σ) _ |
| (coordinateLeafField_measurable (n+1)), ← decoratedLeafIntegral_exp, |
| ← decoratedLeafIntegral_const_mul _ _ _ ENNReal.ofReal_ne_top] |
| apply decoratedLeafIntegral_mono |
| intro x |
| rw [← ENNReal.ofReal_mul (Real.exp_pos _).le,← Real.exp_add,canonicalCoordinatePotential_eq_norm] |
| apply ENNReal.ofReal_le_ofReal |
| convert sphericalExp_le_gaussian n (coordinateLeafField (n+1) x) R hb using 1 |
| congr 1 |
| ring |
|
|
| def coordinateAngularLog (n k : ℕ) (σ : ℕ → ℝ) (R : ℝ) |
| (p : (Fin (n+1) → ℕ → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k) : ℝ := |
| Real.log ((decoratedAngularFactor n (canonicalCoordinateStep (n+1) σ) |
| (coordinateLeafField (n+1)) k p R).toReal / |
| decoratedTerminalTotal (canonicalCoordinateStep (n+1) σ) (fun _ => 0) k p) |
|
|
| lemma coordinateAngularLog_regular (n k : ℕ) (σ : ℕ → ℝ) (R : ℝ) {b : ℝ} (hb : 0 < b) |
| (p : (Fin (n+1) → ℕ → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k) |
| (h0 : 0 < decoratedTerminalTotal (canonicalCoordinateStep (n+1) σ) (fun _ => 0) k p) |
| (hc : 0 < decoratedTerminalTotal (canonicalCoordinateStep (n+1) σ) (canonicalCoordinatePotential (n+1) b) k p) : |
| 0 < (decoratedAngularFactor n (canonicalCoordinateStep (n+1) σ) |
| (coordinateLeafField (n+1)) k p R).toReal ∧ |
| 0 ≤ coordinateAngularLog n k σ R p ∧ |
| coordinateAngularLog n k σ R p ≤ canonicalCoordinateLog (n+1) k σ b p + |
| ((n+1:ℕ):ℝ)*Real.log b/2+b*R^2/2 := by |
| let A := decoratedAngularFactor n (canonicalCoordinateStep (n+1) σ) |
| (coordinateLeafField (n+1)) k p R |
| let B := decoratedTerminalTotalE (canonicalCoordinateStep (n+1) σ) (fun _ => 0) k p |
| let C := decoratedTerminalTotalE (canonicalCoordinateStep (n+1) σ) (canonicalCoordinatePotential (n+1) b) k p |
| let c := ((n+1:ℕ):ℝ)*Real.log b/2+b*R^2/2 |
| have hB : 0 < B.toReal := h0 |
| have hC : 0 < C.toReal := hc |
| obtain ⟨hB₀,hBtop⟩ := ENNReal.toReal_pos_iff.mp hB |
| obtain ⟨hC₀,hCtop⟩ := ENNReal.toReal_pos_iff.mp hC |
| have hba : B ≤ A := decoratedAngularFactor_mass_le n _ (canonicalCoordinateStep_measurable (n+1) σ) |
| _ (coordinateLeafField_measurable (n+1)) k p R |
| have hac : A ≤ ENNReal.ofReal (Real.exp c)*C := decoratedAngularFactor_le_canonical n k σ R hb p |
| have hAtop : A ≠ ∞ := ne_top_of_le_ne_top (ENNReal.mul_ne_top ENNReal.ofReal_ne_top hCtop.ne) hac |
| have hA := ENNReal.toReal_pos (ne_of_gt (hB₀.trans_le hba)) hAtop |
| have hba' := ENNReal.toReal_mono hAtop hba |
| have hac' := ENNReal.toReal_mono (ENNReal.mul_ne_top ENNReal.ofReal_ne_top hCtop.ne) hac |
| rw [ENNReal.toReal_mul,ENNReal.toReal_ofReal (Real.exp_pos _).le] at hac' |
| refine ⟨hA,?_,?_⟩ |
| · exact Real.log_nonneg ((le_div_iff₀ hB).mpr (by simpa using hba')) |
| · have hh := Real.log_le_log (div_pos hA hB) (div_le_div_of_nonneg_right hac' hB.le) |
| rw [Real.log_div (mul_pos (Real.exp_pos c) hC).ne' hB.ne', |
| Real.log_mul (Real.exp_pos c).ne' hC.ne',Real.log_exp] at hh |
| change Real.log (A.toReal/B.toReal) ≤ Real.log (C.toReal/B.toReal)+ |
| ((n+1:ℕ):ℝ)*Real.log b/2+b*R^2/2 |
| rw [Real.log_div hC.ne' hB.ne'] |
| dsimp only [c] at hh |
| linarith |
|
|
| lemma coordinateAngularLog_convex (n k : ℕ) (σ : ℕ → ℝ) {b : ℝ} (hb : 0 < b) |
| (p : (Fin (n+1) → ℕ → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k) |
| (h0 : 0 < decoratedTerminalTotal (canonicalCoordinateStep (n+1) σ) (fun _ => 0) k p) |
| (hc : 0 < decoratedTerminalTotal (canonicalCoordinateStep (n+1) σ) (canonicalCoordinatePotential (n+1) b) k p) : |
| ConvexOn ℝ Set.univ (fun R => coordinateAngularLog n k σ R p) := by |
| let A := fun R => decoratedAngularFactor n (canonicalCoordinateStep (n+1) σ) |
| (coordinateLeafField (n+1)) k p R |
| let B := decoratedTerminalTotal (canonicalCoordinateStep (n+1) σ) (fun _ => 0) k p |
| have hA (R : ℝ) : 0 < (A R).toReal := (coordinateAngularLog_regular n k σ R hb p h0 hc).1 |
| have ht (R : ℝ) : A R ≠ ∞ := (ENNReal.toReal_pos_iff.mp (hA R)).2.ne |
| refine ⟨convex_univ,?_⟩ |
| intro R _ S _ a c ha hc' hac |
| have H := decoratedAngularFactor_holder n (canonicalCoordinateStep (n+1) σ) |
| (canonicalCoordinateStep_measurable (n+1) σ) (coordinateLeafField (n+1)) |
| (coordinateLeafField_measurable (n+1)) k p R S ha hc' hac |
| have Hr := ENNReal.toReal_mono (ENNReal.mul_ne_top |
| (ENNReal.rpow_ne_top_of_nonneg ha (ht R)) (ENNReal.rpow_ne_top_of_nonneg hc' (ht S))) H |
| change (A (a*R+c*S)).toReal ≤ (A R ^ a * A S ^ c).toReal at Hr |
| rw [ENNReal.toReal_mul,← ENNReal.toReal_rpow,← ENNReal.toReal_rpow] at Hr |
| have Hlog := Real.log_le_log (hA (a*R+c*S)) Hr |
| rw [Real.log_mul (Real.rpow_pos_of_pos (hA R) a).ne' (Real.rpow_pos_of_pos (hA S) c).ne', |
| Real.log_rpow (hA R),Real.log_rpow (hA S)] at Hlog |
| simp only [smul_eq_mul] |
| change Real.log ((A (a*R+c*S)).toReal/B) ≤ a*Real.log ((A R).toReal/B)+c*Real.log ((A S).toReal/B) |
| rw [Real.log_div (hA _).ne' h0.ne',Real.log_div (hA R).ne' h0.ne',Real.log_div (hA S).ne' h0.ne'] |
| have hh := congrArg (fun t : ℝ => t * Real.log B) hac |
| nlinarith [Hlog, hh] |
|
|
| lemma coordinateAngularLog_measurable (n k : ℕ) (σ : ℕ → ℝ) (R : ℝ) : |
| Measurable (coordinateAngularLog n k σ R) := by |
| let X := Fin (n+1) → ℕ → ℝ |
| let S := Fin (n+1) → ℝ |
| let F : Spin (n+1) × X → ℝ≥0∞ := fun q => ENNReal.ofReal (Real.exp (inner ℝ (coordinateLeafField (n+1) q.2) q.1)) |
| have hm := decoratedLeafIntegral_param_measurable (canonicalCoordinateStep (n+1) σ) |
| (canonicalCoordinateStep_measurable (n+1) σ) F |
| ((((coordinateLeafField_measurable (n+1)).comp measurable_snd).inner measurable_fst).exp.ennreal_ofReal) k |
| have hmap : Measurable (fun q : (X × DecoratedCascade S k) × Metric.sphere (0:Spin (n+1)) 1 => |
| (R • (q.2:Spin (n+1)),q.1)) := |
| (measurable_snd.subtype_coe.const_smul R).prodMk measurable_fst |
| have hh := hm.comp hmap |
| have ha : Measurable (fun p : X × DecoratedCascade S k => |
| decoratedAngularFactor n (canonicalCoordinateStep (n+1) σ) (coordinateLeafField (n+1)) k p R) := |
| hh.lintegral_prod_right' |
| exact (ha.ennreal_toReal.div (decoratedTerminalTotal_measurable |
| (piMarkLaw (fun _ : Fin (n+1) => standardGaussianMark)) _ |
| (canonicalCoordinateStep_measurable (n+1) σ) measurable_const k (fun _ => 0))).log |
|
|
| lemma coordinateAngularLog_integrable (n k : ℕ) (σ : ℕ → ℝ) {b : ℝ} (R : ℝ) |
| (z : Fin k → ℝ) (hz : StrictMono z) (hz0 : ∀ i, 0 < z i) (hz1 : ∀ i, z i < 1) |
| (hp : 0 < quadraticCascadePrecision σ b k z) (r : ℝ≥0) : |
| Integrable (fun p => coordinateAngularLog n k σ R ((fun i _ => p.1 i),p.2)) |
| (coordinateCascadeLaw (n+1) k z r) := by |
| have hb : 0 < b := hp.trans_le (quadraticCascadePrecision_le σ b k z (fun i => (hz0 i).le)) |
| have hm := (coordinateAngularLog_measurable n k σ R).comp |
| (show Measurable (fun p : (Fin (n+1) → ℝ) × DecoratedCascade (Fin (n+1) → ℝ) k => |
| ((fun (i : Fin (n+1)) (_ : ℕ) => p.1 i),p.2)) from by fun_prop) |
| have hi := (canonical_coordinate_joint_mean (n+1) σ b k z hz hz0 hz1 hp r).1 |
| apply (hi.add (integrable_const (((n+1:ℕ):ℝ)*Real.log b/2+b*R^2/2))).mono' hm.aestronglyMeasurable |
| filter_upwards [canonicalCoordinateBase_pos (n+1) k σ z hz hz0 hz1 r, |
| canonicalCoordinateTotal_pos (n+1) k σ b z hz hz0 hz1 hp r] with p h0 hc |
| have h := coordinateAngularLog_regular n k σ R hb _ h0 hc |
| simp only [Function.comp_apply, Pi.add_apply] |
| rw [Real.norm_eq_abs,abs_of_nonneg h.2.1] |
| linarith [h.2.2] |
|
|
| end SphericalPerceptronFreeEnergy |
| end |
|
|
| end OAI |
|
|
