| import Mathlib |
| import OAI.Probability.SKRatio.Matrices.RandomMatrixNet |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators Topology |
| open Set Metric |
| namespace SKRatio.MatrixNet |
| attribute [local instance] Classical.propDecidable |
|
|
| lemma masked_matrix_norm_le {n : ℕ} (A : Matrix (Fin n) (Fin n) ℝ) |
| (s t : Fin n → Prop) : |
| ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) |
| (fun i j => if s i ∧ t j then A i j else 0)‖ ≤ |
| ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) A‖ := by |
| let D (s : Fin n → Prop) : Matrix (Fin n) (Fin n) ℝ := |
| Matrix.diagonal (fun i => if s i then 1 else 0) |
| have hde (s : Fin n → Prop) : |
| ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) (D s)‖ ≤ 1 := by |
| apply matrix_diagonal_opNorm_le _ 1 zero_le_one |
| intro i |
| split_ifs <;> norm_num |
| have he : (fun i j => if s i ∧ t j then A i j else 0) = D s*A*D t := by |
| ext i j |
| simp only [D,Matrix.diagonal_mul,Matrix.mul_diagonal] |
| split_ifs <;> simp_all |
| rw [he,map_mul,map_mul] |
| calc |
| _ ≤ (‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) (D s)‖* |
| ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) A‖)* |
| ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) (D t)‖ := |
| (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right (norm_mul_le _ _) (norm_nonneg _)) |
| _ ≤ (1*‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) A‖)*1 := |
| mul_le_mul (mul_le_mul_of_nonneg_right (hde s) (norm_nonneg _)) (hde t) |
| (norm_nonneg _) (by positivity) |
| _ = _ := by ring |
|
|
| lemma bin_kernel_decomposition {n : ℕ} {κ : Type*} [Fintype κ] [DecidableEq κ] |
| (A : Matrix (Fin n) (Fin n) ℝ) (b : Fin n → κ) (G : κ → κ → ℝ) : |
| Matrix.of (fun i j => A i j*G (b i) (b j)) = |
| ∑ a : κ, ∑ c : κ, G a c • Matrix.of (fun i j => if b i=a ∧ b j=c then A i j else 0) := by |
| apply Matrix.ext |
| intro i j |
| simp only [Matrix.sum_apply,Matrix.of_apply,Matrix.smul_apply,smul_eq_mul] |
| simp only [mul_ite,mul_zero, ite_and, |
| Finset.sum_ite_irrel,Finset.sum_const_zero,Finset.sum_ite_eq, |
| Finset.mem_univ,ite_true] |
| ring |
|
|
| lemma euclideanCLM_smul {n : ℕ} (a : ℝ) (A : Matrix (Fin n) (Fin n) ℝ) : |
| Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) (a • A) = |
| a • Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) A := by |
| exact map_smul (Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ)) a A |
|
|
| lemma masked_smul_norm_le {n : ℕ} (a : ℝ) (A : Matrix (Fin n) (Fin n) ℝ) |
| (s t : Fin n → Prop) : |
| ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) |
| (a • Matrix.of (fun i j => if s i ∧ t j then A i j else 0))‖ ≤ |
| |a| * ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) A‖ := by |
| rw [euclideanCLM_smul,norm_smul,Real.norm_eq_abs] |
| exact mul_le_mul_of_nonneg_left (masked_matrix_norm_le A s t) (abs_nonneg a) |
|
|
| lemma bin_kernel_norm_le {n : ℕ} {κ : Type*} [Fintype κ] [DecidableEq κ] |
| (A : Matrix (Fin n) (Fin n) ℝ) (b : Fin n → κ) (G : κ → κ → ℝ) : |
| ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) (Matrix.of (fun i j => A i j*G (b i) (b j)))‖ ≤ |
| (∑ a : κ, ∑ c : κ, |G a c|) * ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) A‖ := by |
| let T := Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) |
| let P (a c : κ) : Matrix (Fin n) (Fin n) ℝ := |
| G a c • Matrix.of (fun i j => if b i=a ∧ b j=c then A i j else 0) |
| have hmap : T (∑ a, ∑ c, P a c) = ∑ a, ∑ c, T (P a c) := by |
| rw [map_sum] |
| exact Finset.sum_congr rfl (fun a _ => map_sum T _ _) |
| have hnormsum : ‖∑ a, ∑ c, T (P a c)‖ ≤ ∑ a, ∑ c, ‖T (P a c)‖ := |
| (norm_sum_le _ _).trans (Finset.sum_le_sum (fun a _ => norm_sum_le _ _)) |
| have hbnd : ∑ a, ∑ c, ‖T (P a c)‖ ≤ ∑ a, ∑ c, |G a c| *‖T A‖ := by |
| dsimp only [T,P] |
| apply Finset.sum_le_sum |
| intro a _ |
| apply Finset.sum_le_sum |
| intro c _ |
| convert masked_smul_norm_le (G a c) A (fun i => b i=a) (fun j => b j=c) using 1 |
| try rfl |
| apply congrArg (fun M : Matrix (Fin n) (Fin n) ℝ => |
| ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) M‖) |
| apply Matrix.ext |
| intro i j |
| simp only [Matrix.smul_apply,Matrix.of_apply,smul_eq_mul] |
| split_ifs <;> rfl |
| rw [bin_kernel_decomposition A b G] |
| change ‖T (∑ a, ∑ c, P a c)‖ ≤ _ |
| rw [hmap] |
| apply (hnormsum.trans hbnd).trans_eq |
| simp only [T, Finset.sum_mul] |
|
|
| lemma kernel_error_norm_le {n : ℕ} (A : Matrix (Fin n) (Fin n) ℝ) |
| (G G' : Fin n → Fin n → ℝ) {a C : ℝ} (ha : 0≤a) (hC : 0≤C) |
| (hr : ∀ i, ∑ j, |A i j| ≤ C) (hc : ∀ j, ∑ i, |A i j| ≤ C) |
| (he : ∀ i j, |G i j-G' i j| ≤ a) : |
| ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) (fun i j => A i j*(G i j-G' i j))‖ ≤ a*C := by |
| apply matrix_opNorm_le_schur _ (a*C) (mul_nonneg ha hC) |
| · intro i |
| calc |
| _ ≤ ∑ j, a*|A i j| := Finset.sum_le_sum (fun j _ => by |
| rw [abs_mul,mul_comm] |
| exact mul_le_mul_of_nonneg_right (he i j) (abs_nonneg _)) |
| _ = a*(∑ j, |A i j|) := (Finset.mul_sum ..).symm |
| _ ≤ _ := mul_le_mul_of_nonneg_left (hr i) ha |
| · intro j |
| calc |
| _ ≤ ∑ i, a*|A i j| := Finset.sum_le_sum (fun i _ => by |
| rw [abs_mul,mul_comm] |
| exact mul_le_mul_of_nonneg_right (he i j) (abs_nonneg _)) |
| _ = a*(∑ i, |A i j|) := (Finset.mul_sum ..).symm |
| _ ≤ _ := mul_le_mul_of_nonneg_left (hc j) ha |
| |
| lemma compact_kernel_approximation {X : Type*} [PseudoMetricSpace X] [CompactSpace X] |
| (G : X × X → ℝ) (hG : Continuous G) {a : ℝ} (ha : 0<a) : |
| ∃ (s : Finset X) (b : X → s), ∀ x y, |G (x,y)-G (b x,b y)| ≤ a := by |
| classical |
| obtain ⟨δ,hδ,hcont⟩ := Metric.uniformContinuous_iff.mp (CompactSpace.uniformContinuous_of_continuous hG) a ha |
| obtain ⟨s,_,hs,hcov⟩ := finite_cover_balls_of_compact (X := X) isCompact_univ hδ |
| have hnear (x : X) : ∃ y : {z // z ∈ hs.toFinset}, dist x y < δ := by |
| obtain ⟨y,hy,hxy⟩ := Set.mem_iUnion₂.mp (hcov (Set.mem_univ x)) |
| exact ⟨⟨y,hs.mem_toFinset.mpr hy⟩,hxy⟩ |
| choose b hb using hnear |
| refine ⟨hs.toFinset,b,?_⟩ |
| intro x y |
| have hh := hcont (show dist (x,y) ((b x: X),(b y: X)) < δ by |
| simpa only [Prod.dist_eq,max_lt_iff] using And.intro (hb x) (hb y)) |
| exact (Real.dist_eq _ _ ▸ hh).le |
| |
| theorem continuous_kernel_insertion {X : Type*} [PseudoMetricSpace X] [CompactSpace X] |
| (G : X × X → ℝ) (hG : Continuous G) {C u : ℝ} (hC : 0≤C) (hu : 0<u) : |
| ∃ δ : ℝ, 0<δ ∧ ∀ {n : ℕ} (A : Matrix (Fin n) (Fin n) ℝ), |
| (∀ i, ∑ j, |A i j| ≤ C) → (∀ j, ∑ i, |A i j| ≤ C) → |
| ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) A‖ ≤ δ → |
| ∀ x : Fin n → X, |
| ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) (fun i j => A i j*G (x i,x j))‖ ≤ u := by |
| classical |
| let a := u/(2*(C+1)) |
| have ha : 0<a := by dsimp [a]; positivity |
| obtain ⟨s,b,hb⟩ := compact_kernel_approximation G hG ha |
| let B : ℝ := ∑ k : s, ∑ l : s, |G (k,l)| |
| have hB : 0≤B := Finset.sum_nonneg (fun _ _ => Finset.sum_nonneg (fun _ _ => abs_nonneg _)) |
| let δ := u/(2*(B+1)) |
| have hd : 0<δ := by dsimp [δ]; positivity |
| refine ⟨δ,hd,?_⟩ |
| intro n A hr hc hsmall x |
| have hbin := bin_kernel_norm_le A (fun i => b (x i)) (fun k l => G (k,l)) |
| have herr := kernel_error_norm_le A (fun i j => G (x i,x j)) |
| (fun i j => G (b (x i),b (x j))) ha.le hC hr hc (fun i j => hb (x i) (x j)) |
| have hdecomp : Matrix.of (fun i j => A i j*G (x i,x j)) = |
| Matrix.of (fun i j => A i j*G (b (x i),b (x j))) + |
| Matrix.of (fun i j => A i j*(G (x i,x j)-G (b (x i),b (x j)))) := by |
| apply Matrix.ext |
| intro i j |
| change A i j*G (x i,x j) = A i j*G (b (x i),b (x j)) + A i j*(G (x i,x j)-G (b (x i),b (x j))) |
| ring |
| have hBδ : B*δ ≤ u/2 := by |
| dsimp [δ] |
| rw [←mul_div_assoc] |
| apply (div_le_iff₀ (by positivity : (0:ℝ)<2*(B+1))).mpr |
| nlinarith |
| have haC : a*C ≤ u/2 := by |
| dsimp [a] |
| rw [div_mul_eq_mul_div] |
| apply (div_le_iff₀ (by positivity : (0:ℝ)<2*(C+1))).mpr |
| nlinarith |
| calc |
| _ ≤ B*‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) A‖+a*C := by |
| change ‖Matrix.toEuclideanCLM (n := Fin n) (𝕜 := ℝ) (Matrix.of (fun i j => A i j*G (x i,x j)))‖ ≤ _ |
| rw [hdecomp,map_add] |
| exact (norm_add_le _ _).trans (add_le_add hbin herr) |
| _ ≤ B*δ+a*C := add_le_add_left (mul_le_mul_of_nonneg_left hsmall hB) _ |
| _ ≤ u := by linarith only [hBδ,haC] |
| |
| end SKRatio.MatrixNet |
| |
| end |
| |
| end OAI |
| |
