lean/OAI/Probability/EntangledGames/SpectralEntropy.lean

import OAI.Probability.EntangledGames.Resolvent

namespace OAI

universe u_n u_α u_m u_p u_r u_J

open scoped BigOperators ComplexOrder
open scoped MatrixOrder
open Matrix
open MeasureTheory Filter Set
open scoped Topology

noncomputable section
open scoped BigOperators MatrixOrder ComplexOrder Topology Matrix.Norms.Elementwise
open Matrix MeasureTheory Set
namespace ThresholdParallelRepetition.Resolvent
variable {n : Type u_n} [Fintype n] [DecidableEq n]

local instance matrixContinuousENorm : ContinuousENorm (Matrix n n ℂ) :=
  @SeminormedAddGroup.toContinuousENorm _ inferInstance

local instance matrixPreorder : Preorder (Matrix n n ℂ) :=
  (Matrix.instPartialOrder : PartialOrder (Matrix n n ℂ)).toPreorder

omit [DecidableEq n] in
lemma isClosed_posSemidef : IsClosed {A : Matrix n n ℂ | A.PosSemidef} := by
  simp only [Matrix.posSemidef_iff_dotProduct_mulVec]
  apply IsClosed.inter
  · exact isClosed_eq (by fun_prop) continuous_id
  · have heq : {A : Matrix n n ℂ | ∀ x, 0 ≤ star x ⬝ᵥ (A *ᵥ x)} =
        ⋂ x : n → ℂ, {A | 0 ≤ star x ⬝ᵥ (A *ᵥ x)} := by ext; simp
    change IsClosed {A : Matrix n n ℂ | ∀ x, 0 ≤ star x ⬝ᵥ (A *ᵥ x)}
    rw [heq]
    apply isClosed_iInter
    intro x
    apply isClosed_le continuous_const
    simp only [Matrix.mulVec, dotProduct]
    fun_prop

local instance matrixClosedIci : ClosedIciTopology (Matrix n n ℂ) where
  isClosed_Ici A := by
    exact isClosed_posSemidef.preimage (continuous_id.sub continuous_const)

lemma integral_matrix_nonneg {α : Type u_α} [MeasurableSpace α] {μ : Measure α}
    {f : α → Matrix n n ℂ} (hf : ∀ᵐ s ∂μ, (f s).PosSemidef) :
    (∫ s, f s ∂μ).PosSemidef := by
  apply Matrix.nonneg_iff_posSemidef.mp
  exact @integral_nonneg_of_ae α (Matrix n n ℂ) _ _ _ μ _ _ _
    matrixClosedIci f (hf.mono fun _ h => h.nonneg)

lemma integral_matrix_mono {α : Type u_α} [MeasurableSpace α] {μ : Measure α}
    {f g : α → Matrix n n ℂ} (hf : Integrable f μ) (hg : Integrable g μ)
    (hfg : f ≤ᵐ[μ] g) : (∫ s, f s ∂μ) ≤ ∫ s, g s ∂μ :=
  @integral_mono_ae α (Matrix n n ℂ) _ _ _ μ _ _ _ matrixClosedIci f g hf hg hfg

def spectralLinear (U : Matrix n n ℂ) : (n → ℝ) →L[ℝ] Matrix n n ℂ :=
  LinearMap.toContinuousLinearMap
    { toFun := fun v => U * diagonal (fun i => (v i : ℂ)) * Uᴴ
      map_add' := by
        intro v w
        simp only [Pi.add_apply, Complex.ofReal_add]
        change U * diagonal ((fun i => (v i : ℂ)) + (fun i => (w i : ℂ))) * Uᴴ = _
        erw [← Matrix.diagonal_add]
        rw [mul_add, add_mul]
      map_smul' := by
        intro c v
        simp only [Pi.smul_apply, smul_eq_mul, RingHom.id_apply]
        have hd : diagonal (fun i => ((c * v i : ℝ) : ℂ)) =
            c • diagonal (fun i => (v i : ℂ)) := by
          ext i j
          simp only [Matrix.diagonal_apply, Matrix.smul_apply, Complex.ofReal_mul,
            Complex.real_smul]
          split_ifs <;> simp
        rw [hd, Matrix.mul_smul, Matrix.smul_mul] }

lemma spectralLinear_apply (U : Matrix n n ℂ) (v : n → ℝ) :
    spectralLinear U v = U * diagonal (fun i => (v i : ℂ)) * Uᴴ := rfl

lemma cfc_eq_spectralLinear {A : Matrix n n ℂ} (hA : A.IsHermitian) (f : ℝ → ℝ) :
    cfc f A = spectralLinear (hA.eigenvectorUnitary : Matrix n n ℂ)
      (fun i => f (hA.eigenvalues i)) := by
  rw [hA.cfc_eq]
  rfl

lemma integrable_cfc {α : Type u_α} [MeasurableSpace α] {μ : Measure α}
    {A : Matrix n n ℂ} (hA : A.IsHermitian) (f : α → ℝ → ℝ)
    (hf : ∀ i, Integrable (fun s => f s (hA.eigenvalues i)) μ) :
    Integrable (fun s => cfc (f s) A) μ := by
  simp_rw [cfc_eq_spectralLinear hA]
  exact (spectralLinear _).integrable_comp (Integrable.of_eval hf)

lemma integral_cfc {α : Type u_α} [MeasurableSpace α] {μ : Measure α}
    {A : Matrix n n ℂ} (hA : A.IsHermitian) (f : α → ℝ → ℝ)
    (hf : ∀ i, Integrable (fun s => f s (hA.eigenvalues i)) μ) :
    (∫ s, cfc (f s) A ∂μ) = cfc (fun t => ∫ s, f s t ∂μ) A := by
  simp_rw [cfc_eq_spectralLinear hA]
  erw [(spectralLinear _).integral_comp_comm (Integrable.of_eval hf)]
  congr 1
  ext i
  exact eval_integral hf i

end ThresholdParallelRepetition.Resolvent

noncomputable section
open scoped BigOperators ComplexOrder MatrixOrder Matrix.Norms.Elementwise Topology
open Matrix MeasureTheory Filter Set
namespace ThresholdParallelRepetition.Resolvent
attribute [local instance] matrixContinuousENorm matrixPreorder matrixClosedIci
variable {n : Type u_n} [Fintype n] [DecidableEq n]

lemma spectrum_nonneg {A : Matrix n n ℂ} (hA : A.PosSemidef)
    {t : ℝ} (ht : t ∈ spectrum ℝ A) : 0 ≤ t := by
  rw [hA.isHermitian.spectrum_real_eq_range_eigenvalues] at ht
  obtain ⟨i, rfl⟩ := ht
  exact hA.eigenvalues_nonneg i

lemma eigenvalues_le_one {A : Matrix n n ℂ} (hA : A.PosSemidef)
    (hA1 : A ≤ 1) (i : n) : hA.isHermitian.eigenvalues i ≤ 1 := by
  have h : cfc (fun t : ℝ => t) A ≤ cfc (fun _ : ℝ => (1 : ℝ)) A := by
    erw [cfc_id' ℝ A hA.isHermitian, cfc_const (1 : ℝ) A hA.isHermitian,
      map_one]
    exact hA1
  exact (cfc_le_iff (fun t : ℝ => t) (fun _ : ℝ => (1 : ℝ)) A
    (ha := hA.isHermitian)).mp h _ (hA.isHermitian.eigenvalues_mem_spectrum_real i)

lemma resolvent_cfc {A : Matrix n n ℂ} (hA : A.PosSemidef)
    {s : ℝ} (hs : 0 < s) :
    resolvent A s = cfc (fun t : ℝ => (t + s)⁻¹) A := by
  erw [cfc_inv (fun t : ℝ => t + s) A
    (fun t ht => ne_of_gt (add_pos_of_nonneg_of_pos (spectrum_nonneg hA ht) hs))
    (ha := hA.isHermitian)]
  erw [cfc_add A (fun t : ℝ => t) (fun _ : ℝ => s),
    cfc_id' ℝ A hA.isHermitian, cfc_const s A hA.isHermitian,
    Algebra.algebraMap_eq_smul_one, ← Matrix.nonsing_inv_eq_ringInverse]
  rfl

lemma purificationKernel_cfc {A : Matrix n n ℂ} (hA : A.PosSemidef)
    {s : ℝ} (hs : 0 < s) :
    purificationKernel A s = cfc (fun t : ℝ => t / (t + s)) A := by
  rw [purificationKernel, resolvent_cfc hA hs]
  calc
    A * cfc (fun t : ℝ => (t + s)⁻¹) A =
        cfc (fun t : ℝ => t) A * cfc (fun t : ℝ => (t + s)⁻¹) A := by
      erw [cfc_id' ℝ A hA.isHermitian]
    _ = _ := by
      rw [← cfc_mul (fun t : ℝ => t) (fun t : ℝ => (t + s)⁻¹) A
        (hg := A.finite_real_spectrum.continuousOn _)]
      rfl

lemma purificationKernel_square_cfc {A : Matrix n n ℂ} (hA : A.PosSemidef)
    {s : ℝ} (hs : 0 < s) :
    (purificationKernel A s)ᴴ * purificationKernel A s =
      cfc (fun t : ℝ => t ^ 2 / (t + s) ^ 2) A := by
  rw [purificationKernel_cfc hA hs,
    (cfc_predicate (fun t : ℝ => t / (t + s)) A).isHermitian.eq,
    ← cfc_mul (fun t : ℝ => t / (t + s)) (fun t : ℝ => t / (t + s)) A
      (A.finite_real_spectrum.continuousOn _) (A.finite_real_spectrum.continuousOn _)]
  apply cfc_congr
  intro t _
  change t / (t + s) * (t / (t + s)) = t ^ 2 / (t + s) ^ 2
  rw [← pow_two, div_pow]

lemma kernel_square_integrable {A : Matrix n n ℂ} (hA : A.PosSemidef) :
    IntegrableOn (fun s : ℝ => (purificationKernel A s)ᴴ * purificationKernel A s)
      (Ioi 0) := by
  have hi := integrable_cfc hA.isHermitian (fun (s t : ℝ) => t ^ 2 / (t + s) ^ 2)
    (fun i => (scalar_square_integral (hA.eigenvalues_nonneg i)).1)
  apply hi.congr
  filter_upwards [ae_restrict_mem measurableSet_Ioi] with s hs
  exact (purificationKernel_square_cfc hA hs).symm

lemma kernel_square_integral {A : Matrix n n ℂ} (hA : A.PosSemidef) :
    (∫ s : ℝ in Ioi 0, (purificationKernel A s)ᴴ * purificationKernel A s) = A := by
  calc
    _ = ∫ s : ℝ in Ioi 0, cfc (fun t : ℝ => t ^ 2 / (t + s) ^ 2) A := by
      apply integral_congr_ae
      filter_upwards [ae_restrict_mem measurableSet_Ioi] with s hs
      exact purificationKernel_square_cfc hA hs
    _ = cfc (fun t : ℝ => ∫ s : ℝ in Ioi 0, t ^ 2 / (t + s) ^ 2) A :=
      integral_cfc hA.isHermitian _ (fun i => (scalar_square_integral (hA.eigenvalues_nonneg i)).1)
    _ = cfc (fun t : ℝ => t) A := by
      apply cfc_congr
      intro t ht
      exact (scalar_square_integral (spectrum_nonneg hA ht)).2
    _ = A := cfc_id' ℝ A hA.isHermitian

def effectEntropy (A : Matrix n n ℂ) : Matrix n n ℂ := cfc (fun t : ℝ => t * Real.log t) A

def entropyIntegrand (A : Matrix n n ℂ) (s : ℝ) : Matrix n n ℂ :=
  (1 / (1 + s) : ℝ) • A - purificationKernel A s

lemma entropyIntegrand_cfc {A : Matrix n n ℂ} (hA : A.PosSemidef)
    {s : ℝ} (hs : 0 < s) :
    entropyIntegrand A s = cfc (fun t : ℝ => t / (1 + s) - t / (t + s)) A := by
  rw [entropyIntegrand, purificationKernel_cfc hA hs,
    cfc_sub (fun t : ℝ => t / (1 + s)) (fun t : ℝ => t / (t + s)) A
      (A.finite_real_spectrum.continuousOn _) (A.finite_real_spectrum.continuousOn _)]
  congr 1
  calc
    _ = cfc (fun t : ℝ => (1 / (1 + s)) • t) A := by
      erw [cfc_smul (1 / (1 + s) : ℝ) (fun t : ℝ => t) A,
        cfc_id' ℝ A hA.isHermitian]
    _ = _ := by apply cfc_congr; intro t _; simp [smul_eq_mul, div_eq_mul_inv, mul_comm]

lemma entropy_integrable {A : Matrix n n ℂ} (hA : A.PosSemidef) (hA1 : A ≤ 1) :
    IntegrableOn (entropyIntegrand A) (Ioi 0) := by
  have hi := integrable_cfc hA.isHermitian
    (fun (s t : ℝ) => t / (1 + s) - t / (t + s))
    (fun i => (scalar_entropy_integral (hA.eigenvalues_nonneg i) (eigenvalues_le_one hA hA1 i)).1)
  apply hi.congr
  filter_upwards [ae_restrict_mem measurableSet_Ioi] with s hs
  exact (entropyIntegrand_cfc hA hs).symm

lemma entropy_integral {A : Matrix n n ℂ} (hA : A.PosSemidef) (hA1 : A ≤ 1) :
    (∫ s : ℝ in Ioi 0, entropyIntegrand A s) = effectEntropy A := by
  calc
    _ = ∫ s : ℝ in Ioi 0, cfc (fun t : ℝ => t / (1 + s) - t / (t + s)) A := by
      apply integral_congr_ae
      filter_upwards [ae_restrict_mem measurableSet_Ioi] with s hs
      exact entropyIntegrand_cfc hA hs
    _ = cfc (fun t : ℝ => ∫ s : ℝ in Ioi 0, t / (1 + s) - t / (t + s)) A :=
      integral_cfc hA.isHermitian _ (fun i =>
        (scalar_entropy_integral (hA.eigenvalues_nonneg i) (eigenvalues_le_one hA hA1 i)).1)
    _ = effectEntropy A := by
      apply cfc_congr
      intro t ht
      rw [hA.isHermitian.spectrum_real_eq_range_eigenvalues] at ht
      obtain ⟨i, rfl⟩ := ht
      exact (scalar_entropy_integral (hA.eigenvalues_nonneg i) (eigenvalues_le_one hA hA1 i)).2

end ThresholdParallelRepetition.Resolvent

noncomputable section
open scoped BigOperators ComplexOrder MatrixOrder Matrix.Norms.Elementwise Topology
open Matrix MeasureTheory Filter Set
namespace ThresholdParallelRepetition.Resolvent
attribute [local instance] matrixContinuousENorm matrixPreorder matrixClosedIci
variable {n : Type u_n} [Fintype n] [DecidableEq n]
local instance rectContinuousENorm {m : Type u_m} {p : Type u_p} [Fintype m] [Fintype p] :
    ContinuousENorm (Matrix m p ℂ) :=
  @SeminormedAddGroup.toContinuousENorm _ inferInstance

lemma scalar_kernel_memLp {t : ℝ} (ht : 0 ≤ t) :
    MemLp (fun s : ℝ => t / (t + s)) 2 (volume.restrict (Ioi 0)) := by
  have hm : Measurable (fun s : ℝ => t / (t + s)) := by fun_prop
  apply (memLp_two_iff_integrable_sq hm.aestronglyMeasurable).2
  simpa only [IntegrableOn, div_pow] using (scalar_square_integral ht).1

lemma kernel_entry_memLp {A : Matrix n n ℂ} (hA : A.PosSemidef) (i j : n) :
    MemLp (fun s : ℝ => purificationKernel A s i j) 2 (volume.restrict (Ioi 0)) := by
  let U : Matrix n n ℂ := hA.isHermitian.eigenvectorUnitary
  let t : n → ℝ := hA.isHermitian.eigenvalues
  have hf (k : n) : MemLp (fun s : ℝ => U i k * (t k / (t k + s) : ℝ) * star (U j k))
      2 (volume.restrict (Ioi 0)) :=
    (((scalar_kernel_memLp (hA.eigenvalues_nonneg k)).ofReal (K := ℂ)).const_mul
      (U i k)).mul_const (star (U j k))
  have hi := memLp_finsetSum Finset.univ (fun k _ => hf k)
  apply hi.ae_eq
  filter_upwards [ae_restrict_mem measurableSet_Ioi] with s hs
  rw [purificationKernel_cfc hA hs, hA.isHermitian.cfc_eq]
  change (∑ k, U i k * (t k / (t k + s) : ℝ) * star (U j k)) =
    (U * diagonal (fun k => ((t k / (t k + s) : ℝ) : ℂ)) * Uᴴ) i j
  simp only [Matrix.mul_apply, Matrix.diagonal_apply, Matrix.conjTranspose_apply,
    mul_ite, mul_zero, Finset.sum_ite_eq', Finset.mem_univ, ite_true]

lemma integrable_gram {α : Type u_α} [MeasurableSpace α] {μ : Measure α}
    {m : Type u_m} {p : Type u_p} {r : Type u_r} [Fintype m] [Fintype p] [Fintype r]
    {f : α → Matrix r m ℂ} {g : α → Matrix r p ℂ}
    (hf : ∀ i j, MemLp (fun s => f s i j) 2 μ)
    (hg : ∀ i j, MemLp (fun s => g s i j) 2 μ) :
    Integrable (fun s => (f s)ᴴ * g s) μ := by
  apply Integrable.of_eval
  intro i
  apply Integrable.of_eval
  intro j
  change Integrable (fun s => ∑ k, star (f s k i) * g s k j) μ
  apply integrable_finsetSum
  intro k _
  exact memLp_one_iff_integrable.mp ((hf k i).star.mul (hg k j))

lemma kernel_cross_integrable {A B : Matrix n n ℂ} (hA : A.PosSemidef) (hB : B.PosSemidef) :
    IntegrableOn (fun s : ℝ => (purificationKernel A s)ᴴ * purificationKernel B s) (Ioi 0) :=
  integrable_gram (kernel_entry_memLp hA) (kernel_entry_memLp hB)

lemma kernel_distance_integrable {A B : Matrix n n ℂ}
    (hA : A.PosSemidef) (hB : B.PosSemidef) :
    IntegrableOn (fun s : ℝ => (purificationKernel A s - purificationKernel B s)ᴴ *
      (purificationKernel A s - purificationKernel B s)) (Ioi 0) := by
  apply integrable_gram <;> intro i j <;>
    exact (kernel_entry_memLp hA i j).sub (kernel_entry_memLp hB i j)

end ThresholdParallelRepetition.Resolvent

noncomputable section
open scoped BigOperators ComplexOrder MatrixOrder Matrix.Norms.Elementwise Topology
open Matrix MeasureTheory Filter Set
namespace ThresholdParallelRepetition.Resolvent
attribute [local instance] matrixContinuousENorm matrixPreorder matrixClosedIci
variable {n : Type u_n} [Fintype n] [DecidableEq n]

lemma entropy_gap_integrand_eq {J : Type u_J} [Fintype J]
    (A : J → Matrix n n ℂ) (w : J → ℝ) (B : Matrix n n ℂ)
    (hA : ∀ j, (A j).PosSemidef) (hB : B.PosSemidef)
    (hw : ∑ j, w j = 1) (hmean : ∑ j, w j • A j = B)
    {s : ℝ} (hs : 0 < s) :
    (∑ j, w j • entropyIntegrand (A j) s) - entropyIntegrand B s =
      s • ∑ j, w j • (resolvent (A j) s - resolvent B s) := by
  have hc (c : ℝ) : ∑ j, w j • (c • A j) = c • B := by
    simp_rw [smul_comm (w _) c]
    rw [← Finset.smul_sum, hmean]
  have hone : ∑ j, w j • (1 : Matrix n n ℂ) = 1 := by
    rw [← Finset.sum_smul, hw, one_smul]
  have hr : ∑ j, w j • (s • resolvent (A j) s) = s • ∑ j, w j • resolvent (A j) s := by
    simp_rw [smul_comm (w _) s]
    rw [Finset.smul_sum]
  simp_rw [entropyIntegrand, purificationKernel_eq (hA _) hs, purificationKernel_eq hB hs,
    smul_sub, Finset.sum_sub_distrib]
  rw [hc, hone, hr, ← Finset.sum_smul, hw, one_smul]
  module

lemma weighted_distance_jensen {J : Type u_J} [Fintype J]
    (A : J → Matrix n n ℂ) (w : J → ℝ) (B : Matrix n n ℂ)
    (hA : ∀ j, (A j).PosSemidef) (hA1 : ∀ j, A j ≤ 1)
    (hB : B.PosSemidef) (hB1 : B ≤ 1)
    (hw0 : ∀ j, 0 ≤ w j) (hw : ∑ j, w j = 1) (hmean : ∑ j, w j • A j = B) :
    (∑ j, w j • (∫ s : ℝ in Ioi 0,
        (purificationKernel (A j) s - purificationKernel B s)ᴴ *
          (purificationKernel (A j) s - purificationKernel B s))) ≤
      (∑ j, w j • effectEntropy (A j)) - effectEntropy B := by
  have hf (j : J) := (kernel_distance_integrable (hA j) hB).smul (w j)
  have hg (j : J) := (entropy_integrable (hA j) (hA1 j)).smul (w j)
  have hleft := integrable_finsetSum Finset.univ (fun j _ => hf j)
  have hright := (integrable_finsetSum Finset.univ (fun j _ => hg j)).sub
    (entropy_integrable hB hB1)
  have hi := integral_matrix_mono hleft hright (show
      (fun s => ∑ j, w j • ((purificationKernel (A j) s - purificationKernel B s)ᴴ *
        (purificationKernel (A j) s - purificationKernel B s))) ≤ᵐ[volume.restrict (Ioi 0)]
      (fun s => (∑ j, w j • entropyIntegrand (A j) s) - entropyIntegrand B s) from by
    filter_upwards [ae_restrict_mem measurableSet_Ioi] with s hs
    rw [entropy_gap_integrand_eq A w B hA hB hw hmean hs]
    exact weighted_kernel_square_le A w B hA hB hw0 hw hmean hs)
  erw [integral_finsetSum _ (fun j _ => hf j),
    integral_sub (integrable_finsetSum Finset.univ (fun j _ => hg j))
      (entropy_integrable hB hB1),
    integral_finsetSum _ (fun j _ => hg j)] at hi
  simp only [Pi.smul_apply] at hi
  simp_rw [integral_smul, entropy_integral (hA _) (hA1 _), entropy_integral hB hB1] at hi
  exact hi

end ThresholdParallelRepetition.Resolvent

end
end
end
end

end OAI