| import Mathlib |
| import OAI.Probability.SKGap.Localization.ConditionalTolerance |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace SKGap |
| open Matrix Real |
| open scoped MatrixOrder Matrix.Norms.L2Operator |
| variable {ι : Type*} [Fintype ι] [DecidableEq ι] |
|
|
| lemma sqrt_half_holder {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) : |
| |sqrt a-sqrt b| ≤ sqrt |a-b| := by |
| have hsq : (sqrt a-sqrt b)^2 ≤ |a-b| := by |
| rcases le_total a b with hab | hab |
| · rw [abs_of_nonpos (sub_nonpos.mpr hab)] |
| have hp := mul_nonneg (sqrt_nonneg a) (sub_nonneg.mpr (sqrt_le_sqrt hab)) |
| nlinarith [sq_sqrt ha,sq_sqrt hb] |
| · rw [abs_of_nonneg (sub_nonneg.mpr hab)] |
| have hp := mul_nonneg (sqrt_nonneg b) (sub_nonneg.mpr (sqrt_le_sqrt hab)) |
| nlinarith [sq_sqrt ha,sq_sqrt hb] |
| simpa only [sqrt_sq_eq_abs] using sqrt_le_sqrt hsq |
|
|
| def diagonalRoot (a : ι → ℝ) : Matrix ι ι ℝ := diagonal (fun i => sqrt (a i)) |
| def diagonalHessian (a : ι → ℝ) (K : Matrix ι ι ℝ) : Matrix ι ι ℝ := |
| 1-diagonalRoot a*K*diagonalRoot a |
|
|
| lemma diagonalRoot_norm {a : ι → ℝ} {M : ℝ} (_hM : 0 ≤ M) (ha : ∀ i,a i ≤ M) : |
| ‖diagonalRoot a‖ ≤ sqrt M := by |
| rw [diagonalRoot,Matrix.l2_opNorm_diagonal] |
| exact (pi_norm_le_iff_of_nonneg (sqrt_nonneg M)).mpr |
| (fun i => by rw [Real.norm_eq_abs,abs_of_nonneg (sqrt_nonneg _)]; exact sqrt_le_sqrt (ha i)) |
|
|
| lemma diagonalRoot_half_holder {a b : ι → ℝ} {ζ : ℝ} (_hζ : 0 ≤ ζ) |
| (ha : ∀ i,0 ≤ a i) (hb : ∀ i,0 ≤ b i) (hab : ∀ i,|a i-b i| ≤ ζ) : |
| ‖diagonalRoot a-diagonalRoot b‖ ≤ sqrt ζ := by |
| rw [diagonalRoot,diagonalRoot,Matrix.diagonal_sub,Matrix.l2_opNorm_diagonal] |
| exact (pi_norm_le_iff_of_nonneg (sqrt_nonneg ζ)).mpr (fun i => |
| (sqrt_half_holder (ha i) (hb i)).trans (sqrt_le_sqrt (hab i))) |
|
|
| theorem diagonalHessian_half_holder {a b : ι → ℝ} {M ζ L : ℝ} |
| (hM : 0 ≤ M) (hζ : 0 ≤ ζ) (hL : 0 ≤ L) |
| (ha : ∀ i,a i ∈ Set.Icc 0 M) (hb : ∀ i,b i ∈ Set.Icc 0 M) |
| (hab : ∀ i,|a i-b i| ≤ ζ) (K : Matrix ι ι ℝ) (hK : ‖K‖ ≤ L) : |
| ‖diagonalHessian a K-diagonalHessian b K‖ ≤ 2*sqrt M*L*sqrt ζ := by |
| have hD := diagonalRoot_norm hM (fun i => (ha i).2) |
| have hE := diagonalRoot_norm hM (fun i => (hb i).2) |
| have hDE := diagonalRoot_half_holder hζ (fun i => (ha i).1) (fun i => (hb i).1) hab |
| have heq : diagonalHessian a K-diagonalHessian b K= |
| -((diagonalRoot a-diagonalRoot b)*K*diagonalRoot a+ |
| diagonalRoot b*K*(diagonalRoot a-diagonalRoot b)) := by |
| simp only [diagonalHessian,Matrix.sub_mul,Matrix.mul_sub] |
| abel |
| rw [heq,norm_neg] |
| apply (norm_add_le _ _).trans |
| apply (add_le_add (norm_mul_le _ _) (norm_mul_le _ _)).trans |
| have hb₁ : ‖(diagonalRoot a-diagonalRoot b)*K‖ ≤ sqrt ζ*L := |
| (norm_mul_le _ _).trans (mul_le_mul hDE hK (norm_nonneg _) (sqrt_nonneg _)) |
| have hb₂ : ‖diagonalRoot b*K‖ ≤ sqrt M*L := |
| (norm_mul_le _ _).trans (mul_le_mul hE hK (norm_nonneg _) (sqrt_nonneg _)) |
| apply (add_le_add (mul_le_mul hb₁ hD (norm_nonneg _) (by positivity)) |
| (mul_le_mul hb₂ hDE (norm_nonneg _) (by positivity))).trans_eq |
| ring |
|
|
| lemma diagonalHessian_hermitian (a : ι → ℝ) {K : Matrix ι ι ℝ} (hK : K.IsHermitian) : |
| (diagonalHessian a K).IsHermitian := by |
| unfold diagonalHessian Matrix.IsHermitian |
| simp only [Matrix.conjTranspose_sub,Matrix.conjTranspose_one,Matrix.conjTranspose_mul, |
| diagonalRoot,Matrix.diagonal_conjTranspose,star_trivial,hK.eq] |
| simp only [Matrix.mul_assoc] |
|
|
| lemma matrix_quadratic_op_bound (M : Matrix ι ι ℝ) (x : ι → ℝ) : |
| |x ⬝ᵥ (M*ᵥx)| ≤ ‖M‖*(x⬝ᵥx) := by |
| let y : EuclideanSpace ℝ ι := WithLp.toLp 2 x |
| have hh := abs_real_inner_le_norm y (M.toEuclideanLin.toContinuousLinearMap y) |
| have hn := M.toEuclideanLin.toContinuousLinearMap.le_opNorm y |
| have hin : inner ℝ y (M.toEuclideanLin.toContinuousLinearMap y)=x⬝ᵥ(M*ᵥx) := by |
| change (∑ i,(M*ᵥx) i*x i)=∑ i,x i*(M*ᵥx) i |
| apply Finset.sum_congr rfl; intro i _; ring |
| have hy : ‖y‖^2=x⬝ᵥx := by |
| rw [EuclideanSpace.real_norm_sq_eq] |
| simp only [y,dotProduct,pow_two] |
| rw [hin] at hh |
| calc |
| _ ≤ ‖y‖*‖M.toEuclideanLin.toContinuousLinearMap y‖ := hh |
| _ ≤ ‖y‖*(‖M‖*‖y‖) := mul_le_mul_of_nonneg_left hn (norm_nonneg _) |
| _ = _ := by rw [← hy]; ring |
|
|
| theorem hermitian_margin_transfer {S T : Matrix ι ι ℝ} (hS : S.IsHermitian) |
| (_hT : T.IsHermitian) {c d : ℝ} (hd : ‖S-T‖ ≤ d) |
| (hc : (T-c • (1 : Matrix ι ι ℝ)).PosSemidef) : |
| (S-(c-d) • (1 : Matrix ι ι ℝ)).PosSemidef := by |
| refine Matrix.posSemidef_iff_dotProduct_mulVec.mpr ⟨?_,?_⟩ |
| · exact hS.sub (Matrix.isHermitian_one.smul (R := ℝ) (isSelfAdjoint_iff.mpr (star_trivial _))) |
| · intro x |
| have hq := matrix_quadratic_op_bound (S-T) x |
| have hp := hc.dotProduct_mulVec_nonneg x |
| have hxx : 0 ≤ x⬝ᵥx := Finset.sum_nonneg (fun i _ => mul_self_nonneg (x i)) |
| have hbd := mul_le_mul_of_nonneg_right hd hxx |
| simp only [star_trivial,Matrix.sub_mulVec,Matrix.smul_mulVec,Matrix.one_mulVec, |
| dotProduct_sub,dotProduct_smul,smul_eq_mul] at hp hq ⊢ |
| rcases abs_le.mp (hq.trans hbd) with ⟨hl,_⟩ |
| nlinarith only [hp,hl] |
| end SKGap |
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace SKGap |
| open Real Matrix MeasureTheory ProbabilityTheory Set |
| open scoped BigOperators Matrix.Norms.Frobenius |
|
|
| def empiricalConditionalMiddle {n : ℕ} [NeZero n] (j t σ : ℝ) (y : Fin n → ℝ) |
| (g : MatrixCoordinates (Fin n) → ℝ) : Matrix (Fin n) (Fin n) ℝ := |
| let p : ScalarPoint := (empiricalLaw y,t,σ) |
| let q := scalarQMoment p.1 |
| let s := scalarS j p |
| let u := (empiricalUnit y q).ofLp |
| let X := (empiricalGramColumns y (scalarD j p) s 0).ofLp |
| let Z := sqrt s • (empiricalGramColumns y (scalarD j p) s 2).ofLp |
| conditionalBlockMatrix (j/(n:ℝ)) j q s (s+j*q) (scalarA j p) |
| (j*scalarBMoment p.1) (conditionalKappa j p) (conditionalEll j p) u Z g+ |
| j • vecMulVec X X+(2*j*q) • vecMulVec u u- |
| (j*scalarBMoment p.1) • (1 : Matrix (Fin n) (Fin n) ℝ) |
|
|
| lemma empirical_columns_one {n : ℕ} (y : Fin n → ℝ) (d s : ℝ) {q : ℝ} |
| (hq : 0 < q) : sqrt q • (empiricalUnit y q).ofLp=(empiricalGramColumns y d s 1).ofLp := by |
| have hsq : sqrt q ≠ 0 := (sqrt_pos.mpr hq).ne' |
| ext i |
| simp only [empiricalUnit,empiricalGramColumns,gramCoordinates,WithLp.ofLp_toLp, |
| Pi.smul_apply,smul_eq_mul,Matrix.cons_val,sqrt_mul (Nat.cast_nonneg n)] |
| field_simp |
|
|
| lemma empirical_columns_two {n : ℕ} (y : Fin n → ℝ) (d : ℝ) {s : ℝ} |
| (hs : 0 < s) : (sqrt s)⁻¹ • (sqrt s • (empiricalGramColumns y d s 2).ofLp)= |
| (empiricalGramColumns y d s 2).ofLp := by |
| rw [inv_smul_smul₀ (sqrt_pos.mpr hs).ne'] |
|
|
| lemma empirical_columns_matrix {n : ℕ} (y : Fin n → ℝ) (d : ℝ) {q s : ℝ} |
| (hq : 0 < q) (hs : 0 < s) (N : Fin n → ℝ) : |
| conditionalColumns (empiricalGramColumns y d s 0).ofLp |
| (sqrt q • (empiricalUnit y q).ofLp) |
| ((sqrt s)⁻¹ • (sqrt s • (empiricalGramColumns y d s 2).ofLp)) N= |
| extendColumns (fun r=>(empiricalGramColumns y d s r).ofLp) N := by |
| rw [empirical_columns_one y d s hq,empirical_columns_two y d hs] |
| ext i k |
| cases k with |
| | inl k => fin_cases k <;> rfl |
| | inr k => rfl |
|
|
| lemma pathDiagonal_one_eq_sqrt {n : ℕ} (a : Fin n → ℝ) : pathDiagonal a 1=diagonalRoot a := by |
| simp only [pathDiagonal,diagonalRoot,Real.sqrt_one,one_mul] |
|
|
| lemma pathDiagonal_sq {n : ℕ} (a : Fin n → ℝ) (ha : ∀ i,0 ≤ a i) : |
| pathDiagonal a 1*pathDiagonal a 1=diagonal a := by |
| rw [pathDiagonal_one_eq_sqrt,diagonalRoot,Matrix.diagonal_mul_diagonal] |
| congr 1 |
| ext i |
| simp only [← pow_two,Real.sq_sqrt (ha i)] |
|
|
| theorem conditionalEmpiricalCore_eq_hessian {n : ℕ} [NeZero n] (j t σ : ℝ) |
| (a y : Fin n → ℝ) (g : MatrixCoordinates (Fin n) → ℝ) |
| (ha : ∀ i,0 ≤ a i) (hq : 0 < scalarQMoment (empiricalLaw y)) |
| (hs : 0 < scalarS j (empiricalLaw y,t,σ)) (hBA : 0 < j/(n:ℝ)*∑ i,a i) : |
| conditionalEmpiricalCore j t σ a y g=diagonalHessian a (empiricalConditionalMiddle j t σ y g) := by |
| let p : ScalarPoint := (empiricalLaw y,t,σ) |
| let q := scalarQMoment p.1 |
| let s := scalarS j p |
| let B := j*scalarBMoment p.1 |
| let BA := j/(n:ℝ)*∑ i,a i |
| have hh := conditional_hessian_rank_form (j/(n:ℝ)) j (scalarA j p) B |
| (conditionalKappa j p) (conditionalEll j p) (q := q) (s := s) |
| (S := s+j*q) hq hs hBA |
| (empiricalGramColumns y (scalarD j p) s 0).ofLp |
| (empiricalUnit y q).ofLp |
| (sqrt s • (empiricalGramColumns y (scalarD j p) s 2).ofLp) |
| (pathDiagonal a 1) g |
| dsimp only at hh |
| rw [empirical_columns_matrix y (scalarD j p) hq hs,pathDiagonal_sq a ha] at hh |
| have hB : B+(BA-B)=BA := by ring |
| have hbil : goeBilinear (j/(n:ℝ)) (empiricalUnit y q).ofLp (empiricalUnit y q).ofLp g= |
| matrixBilinear (goeMatrix (j/(n:ℝ)) g) (empiricalUnit y q) (empiricalUnit y q) := by |
| rw [matrixBilinear_eq_pair] |
| rfl |
| rw [hbil] at hh |
| symm |
| convert hh using 1 |
| · simp only [diagonalHessian,empiricalConditionalMiddle,p,q,s,B,pathDiagonal_one_eq_sqrt, |
| Matrix.mul_add,Matrix.mul_sub,Matrix.add_mul,Matrix.sub_mul,Matrix.mul_smul, |
| Matrix.smul_mul,Matrix.mul_one] |
| abel |
| · simp only [conditionalEmpiricalCore,conditionalBase,conditionalUpdateColumns, |
| conditionalMeanData,conditionalScalarData,p,q,s,B,BA] at * |
| rw [hB] |
| end SKGap |
| end |
| end |
|
|
| end OAI |
|
|
