| import OAI.Analysis.FreeEntropy.GUECovariance |
|
|
| namespace OAI |
|
|
| universe u1 u2 u3 u4 u5 u6 u7 u8 |
|
|
| noncomputable section |
| open MeasureTheory ProbabilityTheory Finset Filter |
| open scoped Classical Topology |
| namespace FiniteEntropySeparation |
| theorem matrixTraceWord_cyclic {α : Type u1} {d : ℕ} (A : α → Matrix (Fin d) (Fin d) ℂ) (u v : List α) : |
| matrixTraceWord A (u++v) = matrixTraceWord A (v++u) := by |
| simp only [matrixTraceWord, matrixWord_append] |
| rw [Matrix.trace_mul_comm] |
| theorem matrixWord_map {α : Type u2} {β : Type u3} {d : ℕ} (A : β → Matrix (Fin d) (Fin d) ℂ) (f : α → β) (w : List α) : |
| matrixWord A (w.map f) = matrixWord (A ∘ f) w := by simp [matrixWord,List.map_map] |
| theorem matrixTraceWord_map {α : Type u4} {β : Type u5} {d : ℕ} (A : β → Matrix (Fin d) (Fin d) ℂ) (f : α → β) (w : List α) : |
| matrixTraceWord A (w.map f) = matrixTraceWord (A ∘ f) w := by simp [matrixTraceWord,matrixWord_map] |
| theorem sum_word_left_or_noise {α : Type u6} {β : Type u7} (w : List (α ⊕ β)) : |
| (∃ u : List α, w=u.map Sum.inl) ∨ (∃ u i v, w=u++Sum.inr i::v) := by |
| induction w with |
| | nil => exact Or.inl ⟨[],rfl⟩ |
| | cons a w ih => |
| cases a with |
| | inl a => |
| rcases ih with ⟨u,rfl⟩ | ⟨u,i,v,rfl⟩ |
| · exact Or.inl ⟨a::u,rfl⟩ |
| · exact Or.inr ⟨Sum.inl a::u,i,v,rfl⟩ |
| | inr i => exact Or.inr ⟨[],i,w,rfl⟩ |
| theorem tendsto_of_sub_zero {f g : ℕ → ℂ} {z : ℂ} (hfg : Tendsto (fun k => f k-g k) atTop (𝓝 0)) |
| (hg : Tendsto g atTop (𝓝 z)) : Tendsto f atTop (𝓝 z) := by |
| simpa only [sub_add_cancel, zero_add] using hfg.add hg |
| variable {α : Type u8} {n : ℕ} {D : ℕ → ℕ} |
| def expectedMatrixWord (A : (k : ℕ) → α → Matrix (Fin (D k)) (Fin (D k)) ℂ) (k : ℕ) (w : List (α ⊕ Fin n)) : ℂ := |
| ∫ x, matrixTraceWord (jointMatrix (A k) x) w ∂productGaussian (MatrixIndex n (D k)) |
| theorem matrixTraceWord_covariance_tendsto (hD0 : ∀ k, 0 < D k) (hD : Tendsto D atTop atTop) |
| (A : (k : ℕ) → α → Matrix (Fin (D k)) (Fin (D k)) ℂ) {R : ℝ} (hR : 0 ≤ R) |
| (hA : ∀ k a, matrixOpNorm (A k a) ≤ R) (u v : List (α ⊕ Fin n)) : |
| Tendsto (fun k => (∫ x, matrixTraceWord (jointMatrix (A k) x) u*matrixTraceWord (jointMatrix (A k) x) v ∂productGaussian (MatrixIndex n (D k)))- |
| expectedMatrixWord A k u*expectedMatrixWord A k v) atTop (𝓝 0) := by |
| apply tendsto_zero_of_norm_bound_inv_sq hD (C := ((u.length:ℝ)^2*jointMomentBound n R (2*(u.length-1))+(v.length:ℝ)^2*jointMomentBound n R (2*(v.length-1)))/2) |
| intro k |
| convert matrixTraceWord_covariance_bound (hD0 k) (A k) hR (hA k) u v using 1 |
| · rfl |
| · ring |
| theorem expectedMatrixWord_tendsto (hD0 : ∀ k, 0 < D k) (hD : Tendsto D atTop atTop) |
| (A : (k : ℕ) → α → Matrix (Fin (D k)) (Fin (D k)) ℂ) {R : ℝ} (hR : 0 ≤ R) |
| (hA : ∀ k a, matrixOpNorm (A k a) ≤ R) (M : List (α ⊕ Fin n) → ℂ) |
| (hcyclic : ∀ u v, M (u++v)=M (v++u)) |
| (hbase : ∀ u : List α, Tendsto (fun k => matrixTraceWord (A k) u) atTop (𝓝 (M (u.map Sum.inl)))) |
| (hrec : ∀ (i : Fin n) (w : List (α ⊕ Fin n)), M (Sum.inr i::w) = |
| ∑ r : Fin w.length, if w[r.val]=Sum.inr i then M (w.take r.val)*M (w.drop (r.val+1)) else 0) |
| (w : List (α ⊕ Fin n)) : Tendsto (fun k => expectedMatrixWord A k w) atTop (𝓝 (M w)) := by |
| induction w using (measure List.length).wf.induction with |
| | h w ih => |
| rcases sum_word_left_or_noise w with ⟨u,rfl⟩ | ⟨u,i,v,rfl⟩ |
| · simpa [expectedMatrixWord,matrixTraceWord_map,jointMatrix,Function.comp_def] using hbase u |
| · have hrecLimit : Tendsto (fun k => expectedMatrixWord A k (Sum.inr i::(v++u))) atTop (𝓝 (M (Sum.inr i::(v++u)))) := by |
| simp only [expectedMatrixWord, gueTraceWord_stein (hD0 _), hrec] |
| apply tendsto_finsetSum |
| intro r _ |
| split_ifs with hr |
| · apply tendsto_of_sub_zero (matrixTraceWord_covariance_tendsto hD0 hD A hR hA _ _) |
| apply Tendsto.mul |
| · exact ih ((v++u).take r.val) (by change ((v++u).take r.val).length < (u++Sum.inr i::v).length; have hh:=r.isLt; simp only [List.length_take,List.length_append,List.length_cons] at *; omega) |
| · exact ih ((v++u).drop (r.val+1)) (by change ((v++u).drop (r.val+1)).length < (u++Sum.inr i::v).length; simp only [List.length_drop,List.length_append,List.length_cons]; omega) |
| · exact tendsto_const_nhds |
| convert hrecLimit using 1 |
| · funext k |
| exact congrArg (fun f => ∫ x, f x ∂productGaussian (MatrixIndex n (D k))) (funext (fun x => matrixTraceWord_cyclic (jointMatrix (A k) x) u (Sum.inr i::v))) |
| · exact congrArg (fun z : ℂ => 𝓝 z) (hcyclic u (Sum.inr i::v)) |
| end FiniteEntropySeparation |
|
|
| end |
|
|
| end OAI |
|
|
