| import Mathlib |
| import OAI.Probability.SKRatio.Quantization.BinProcess |
| import OAI.Probability.SKRatio.Variational.ReducedForm |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators Matrix |
| open MeasureTheory ProbabilityTheory Filter Real |
| namespace SKRatio.Planted |
| open SKRatioClock.Regression Scalar |
| attribute [local instance] Classical.propDecidable |
| variable {n : ℕ} |
|
|
| lemma fieldProjection_apply (i j : Fin n) : |
| fieldProjection n i j = (if i=j then 1 else 0)-(n:ℝ)⁻¹ := by |
| simp only [fieldProjection,residualProjection,Matrix.sub_apply,Matrix.one_apply, |
| Matrix.mul_apply,Matrix.transpose_apply,queryColumn,constantDirection,Fin.sum_univ_one] |
| congr 1 |
| rw [←mul_inv_rev,←pow_two,sq_sqrt (Nat.cast_nonneg n)] |
|
|
| lemma fieldProjection_symmetric : (fieldProjection n)ᵀ=fieldProjection n := by |
| ext i j |
| simp only [Matrix.transpose_apply,fieldProjection_apply,eq_comm] |
|
|
| lemma fieldProjection_mulVec (p : Fin n → ℝ) : |
| fieldProjection n *ᵥ p = Bins.centered p := by |
| ext i |
| simp only [Matrix.mulVec,dotProduct,fieldProjection_apply,sub_mul,Finset.sum_sub_distrib, |
| ite_mul,one_mul,zero_mul,Finset.sum_ite_eq,Finset.mem_univ,ite_true, |
| ←Finset.mul_sum,Bins.centered,Bins.average,Fintype.card_fin,div_eq_mul_inv] |
| ring |
|
|
| lemma fieldProjection_vecMul (p : Fin n → ℝ) : |
| p ᵥ* fieldProjection n = Bins.centered p := by |
| rw [←fieldProjection_symmetric,Matrix.vecMul_transpose,fieldProjection_mulVec] |
|
|
| lemma projected_bilinear (M : Matrix (Fin n) (Fin n) ℝ) (p q : Fin n → ℝ) : |
| p ⬝ᵥ ((fieldProjection n*M*fieldProjection n)*ᵥ q) = |
| Bins.centered p ⬝ᵥ (M*ᵥ Bins.centered q) := by |
| rw [←Matrix.mulVec_mulVec,fieldProjection_mulVec,←Matrix.mulVec_mulVec, |
| Matrix.dotProduct_mulVec,fieldProjection_vecMul] |
|
|
| lemma fullCoeff_goe (β : ℝ) (v p : Fin n → ℝ) |
| (g : Bins.Coordinates (Fin n) → ℝ) : |
| (∑ k, Bins.fullCoeff v p (β/sqrt n) k*g k) = |
| p ⬝ᵥ ((fieldProjection n*(β • goe (fun ij => g (.inl ij)))*fieldProjection n)*ᵥ |
| (fun i => v i*p i)) := by |
| rw [projected_bilinear] |
| simp only [Fintype.sum_sum_type,Bins.fullCoeff,zero_mul,Finset.sum_const_zero,add_zero, |
| Fintype.sum_prod_type,dotProduct,Matrix.mulVec,Matrix.smul_apply,smul_eq_mul,goe, |
| Finset.mul_sum] |
| have hs : sqrt (2*(n:ℝ))=sqrt 2*sqrt n := sqrt_mul (by norm_num) _ |
| rw [hs] |
| let x := Bins.centered p |
| let y := Bins.centered (fun i => v i*p i) |
| change (∑ i, ∑ j, β/sqrt n/sqrt 2*(x i*y j+x j*y i)*g (.inl (i,j))) = |
| ∑ i, ∑ j, x i*(β*((g (.inl (i,j))+g (.inl (j,i)))/(sqrt 2*sqrt n))*y j) |
| have he (i j : Fin n) : β/sqrt n/sqrt 2*(x i*y j+x j*y i)*g (.inl (i,j)) = |
| β/(sqrt 2*sqrt n)*(x i*y j*g (.inl (i,j))+x j*y i*g (.inl (i,j))) := by ring |
| simp_rw [he,mul_add,Finset.sum_add_distrib,←Finset.mul_sum] |
| have hswap : (∑ i, ∑ j, x j*y i*g (.inl (i,j)))= |
| ∑ i, ∑ j, x i*y j*g (.inl (j,i)) := Finset.sum_comm |
| rw [hswap] |
| simp only [Finset.mul_sum,←Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| ring |
|
|
| lemma weightedForm_variance_bilinear (M : Matrix (Fin n) (Fin n) ℝ) |
| (H p : Fin n → ℝ) : |
| weightedForm M varianceKernel (fun i => compactWeight (H i)) p = |
| p ⬝ᵥ (M*ᵥ (fun i => v (H i)*p i)) := by |
| simp only [weightedForm,quadratic,varianceKernel,compactV_weight,dotProduct, |
| Matrix.mulVec,Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| ring |
|
|
| def rankForm (H v p : Fin n → ℝ) : ℝ := |
| ((∑ i, p i*H i)*(∑ i, p i*v i)+(∑ i, p i)*(∑ i, p i*H i*v i)- |
| ((∑ i, H i)/(n:ℝ))*(∑ i, p i)*(∑ i, p i*v i))/(n:ℝ) |
|
|
| lemma rank_form_expansion (H v p : Fin n → ℝ) : |
| (∑ i, ∑ j, ((H i+H j-(∑ k, H k)/(n:ℝ))/(n:ℝ))*v j*p i*p j) = |
| rankForm H v p := by |
| simp only [rankForm,add_div,sub_div,add_mul,sub_mul,Finset.sum_add_distrib, |
| Finset.sum_sub_distrib] |
| have h1 (i : Fin n) : (∑ j, H i/(n:ℝ)*v j*p i*p j) = |
| p i*H i*(∑ j, p j*v j)/(n:ℝ) := by |
| rw [Finset.mul_sum,Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro j _ |
| ring |
| have h2 (i : Fin n) : (∑ j, H j/(n:ℝ)*v j*p i*p j) = |
| p i*(∑ j, p j*H j*v j)/(n:ℝ) := by |
| rw [Finset.mul_sum,Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro j _ |
| ring |
| have h3 (i : Fin n) : (∑ j, ((∑ k, H k)/(n:ℝ))/(n:ℝ)*v j*p i*p j) = |
| ((∑ k, H k)/(n:ℝ))*p i*(∑ j, p j*v j)/(n:ℝ) := by |
| conv_rhs => rw [Finset.mul_sum,Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro j _ |
| ring |
| simp_rw [h1,h2,h3] |
| simp only [←Finset.sum_div,←Finset.sum_mul,←Finset.mul_sum] |
|
|
| def deterministicForm (β : ℝ) (H p : Fin n → ℝ) : ℝ := |
| rankForm H (fun i => v (H i)) p + |
| 2*β^2/(n:ℝ)*(∑ i, p i)*(∑ i, p i*m (H i)*v (H i)) + |
| diagonalForm (fun _ _ => β^2/(n:ℝ)) compactF (fun i => compactWeight (H i)) p + |
| weightedForm (fun _ _ => β^2/(n:ℝ)) compactK (fun i => compactWeight (H i)) p |
|
|
| theorem reducedForm_decomposition (hn : 0<n) (β : ℝ) |
| (g : (Fin n × Fin n) → ℝ) (p : Fin n → ℝ) : |
| reducedForm β g p = |
| p ⬝ᵥ ((fieldProjection n*(β • goe g)*fieldProjection n)*ᵥ |
| (fun i => v (augmentedField β g i)*p i)) + |
| deterministicForm β (augmentedField β g) p := by |
| have h1 : weightedForm (augmented β g) varianceKernel |
| (fun i => compactWeight (augmentedField β g i)) p = |
| weightedForm (fieldProjection n*(β • goe g)*fieldProjection n) varianceKernel |
| (fun i => compactWeight (augmentedField β g i)) p + |
| rankForm (augmentedField β g) (fun i => v (augmentedField β g i)) p := by |
| simp only [weightedForm,quadratic,varianceKernel,compactV_weight] |
| simp_rw [augmented_decomposition hn,add_mul,Finset.sum_add_distrib] |
| rw [rank_form_expansion] |
| have h2 : 2*weightedForm (fun _ _ => β^2/(n:ℝ)) meanVarianceKernel |
| (fun i => compactWeight (augmentedField β g i)) p = |
| 2*β^2/(n:ℝ)*(∑ i, p i)*(∑ i, p i*m (augmentedField β g i)*v (augmentedField β g i)) := by |
| simp only [weightedForm,quadratic,meanVarianceKernel,compactV_weight,compactWeight_coe, |
| w,sub_sub_cancel] |
| simp only [Finset.mul_sum,Finset.sum_mul] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| ring |
| dsimp only [reducedForm] |
| rw [h1,h2,weightedForm_variance_bilinear] |
| unfold deterministicForm |
| ring |
|
|
| end SKRatio.Planted |
|
|
| namespace SKRatio.Bins |
| open SKRatioClock.Regression Planted |
| attribute [local instance] Classical.propDecidable |
| variable {n : ℕ} {α : Type*} [Fintype α] [DecidableEq α] |
| variable {I : Type*} [TopologicalSpace I] [CompactSpace I] [Nonempty I] |
|
|
| lemma inl_array_hasLaw : |
| HasLaw (fun g : Coordinates (Fin n) → ℝ => fun ij : Fin n × Fin n => g (.inl ij)) |
| (standardArrayLaw (Fin n × Fin n)) (SKRatioGaussian.gaussianCoordinates (Coordinates (Fin n))) := by |
| exact iIndepFun.hasLaw_pi (fun ij => coordinate_hasLaw (Sum.inl ij : Coordinates (Fin n))) |
| (iIndepFun.precomp Sum.inl_injective coordinates_independent) |
|
|
| def projectedSup (β : ℝ) (v : Fin n → ℝ) (p : I → Fin n → ℝ) |
| (g : (Fin n × Fin n) → ℝ) : ℝ := |
| sSup (Set.range (fun t => p t ⬝ᵥ |
| ((fieldProjection n*(β • goe g)*fieldProjection n)*ᵥ (fun i => v i*p t i)))) |
|
|
| omit [TopologicalSpace I] [CompactSpace I] [Nonempty I] in |
| lemma projectedSup_eq (β : ℝ) (v : Fin n → ℝ) (p : I → Fin n → ℝ) |
| (g : Coordinates (Fin n) → ℝ) : |
| projectedSup β v p (fun ij => g (.inl ij)) = |
| SKRatioGaussian.gaussianSup (fun _ : I => 0) (fun t => fullCoeff v (p t) (β/sqrt n)) g := by |
| unfold projectedSup SKRatioGaussian.gaussianSup |
| congr 2 |
| funext t |
| simp only [SKRatioGaussian.gaussianAffine,zero_add,fullCoeff_goe] |
|
|
| omit [Nonempty I] in |
| lemma projectedSup_continuous [Nonempty (Fin n)] (β : ℝ) (v : Fin n → ℝ) |
| {p : I → Fin n → ℝ} (hp : Continuous p) : Continuous (projectedSup β v p) := by |
| have he : projectedSup β v p = fun g => |
| SKRatioGaussian.gaussianSup (fun _ : I => 0) (fun t => fullCoeff v (p t) (β/sqrt n)) |
| (Sum.elim g (fun _ => 0)) := by |
| ext g |
| exact projectedSup_eq β v p (Sum.elim g (fun _ => 0)) |
| rw [he] |
| apply (SKRatioGaussian.continuous_gaussianSup continuous_const ((continuous_fullCoeff v _).comp hp)).comp |
| apply continuous_pi |
| intro k |
| cases k with |
| | inl ij => exact continuous_apply ij |
| | inr i => exact continuous_const |
|
|
| lemma le_projectedSup [Nonempty (Fin n)] (β : ℝ) (v : Fin n → ℝ) {p : I → Fin n → ℝ} |
| (hp : Continuous p) (g : (Fin n × Fin n) → ℝ) (t : I) : |
| p t ⬝ᵥ ((fieldProjection n*(β • goe g)*fieldProjection n)*ᵥ (fun i => v i*p t i)) ≤ |
| projectedSup β v p g := by |
| have hh := SKRatioGaussian.gaussianAffine_le_gaussianSup (m := fun _ : I => 0) continuous_const |
| ((continuous_fullCoeff v (β/sqrt n)).comp hp) (Sum.elim g (fun _ => 0)) t |
| simpa only [SKRatioGaussian.gaussianAffine,Function.comp_def,zero_add,fullCoeff_goe,←projectedSup_eq,Sum.elim_inl] using hh |
|
|
| theorem projectedSup_tail (hn : 0<n) (σ : Fin n → α) (v b : α → ℝ) |
| (hv : ∀ a, |v a|≤1) {s : α → ℝ} {β : ℝ} (hβ : 0<β) |
| {u : I → Fin n → ℝ} (huc : Continuous u) (hu0 : ∀ t, ZeroSum σ (u t)) |
| (hus : ∀ t, overlap σ (u t) (u t)=s) |
| (hp : ∀ t, ∑ i, (b (σ i)+u t i)^2=1) {a : ℝ} (ha : 0≤a) : |
| (standardArrayLaw (Fin n × Fin n)).real {g | |
| (∑ d, β/sqrt n*sqrt (radicalSq σ (crossCoeff σ v b) (fun a d => v a+v d) s d)* |
| sqrt (s d)*sqrt ((Finset.univ.filter (fun i => σ i=d)).card : ℝ))+a ≤ |
| projectedSup β (fun i => v (σ i)) (fun t i => b (σ i)+u t i) g} ≤ |
| exp (-a^2*(n:ℝ)/(π^2*β^2)) := by |
| have : Nonempty (Fin n) := Fin.pos_iff_nonempty.mp hn |
| have hδ : 0<β/sqrt (n:ℝ) := div_pos hβ (sqrt_pos.mpr (Nat.cast_pos.mpr hn)) |
| have hsup := full_sup_tail σ v b hv hδ huc hu0 hus hp ha |
| have hmeas : MeasurableSet {g | |
| (∑ d, β/sqrt n*sqrt (radicalSq σ (crossCoeff σ v b) (fun a d => v a+v d) s d)* |
| sqrt (s d)*sqrt ((Finset.univ.filter (fun i => σ i=d)).card : ℝ))+a ≤ |
| projectedSup β (fun i => v (σ i)) (fun t i => b (σ i)+u t i) g} := |
| measurableSet_le measurable_const |
| (projectedSup_continuous β _ (continuous_const.add huc)).measurable |
| rw [←inl_array_hasLaw.measureReal_eq hmeas] |
| simp_rw [projectedSup_eq] |
| convert hsup using 1 |
| apply congrArg Real.exp |
| rw [div_pow,sq_sqrt (Nat.cast_nonneg n)] |
| field_simp |
|
|
| end SKRatio.Bins |
|
|
| end |
|
|
| end OAI |
|
|
