lean/OAI/Analysis/JiangSu/Comparison/LocalizedCompression.lean

import Mathlib
import OAI.Analysis.TracialSplitting.PreparedBlocks
import OAI.Analysis.JiangSu.Comparison.CornerDivision

namespace OAI

noncomputable section
namespace DirectComparison
open Pureness CurrentMain Filter Topology
open scoped ComplexOrder

variable {D : Type*} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]

omit [PartialOrder D] [StarOrderedRing D] in
lemma cornerCFC_mem {u : D} (hu : IsStarProjection u) (x : D) (f : ℝ → ℝ) :
    u*cornerCFC hu x f = cornerCFC hu x f ∧ cornerCFC hu x f*u = cornerCFC hu x f :=
  (cfc f (ProjectionCorner.compress hu x) : ProjectionCorner hu).property

lemma cornerCFC_nonneg {u : D} (hu : IsStarProjection u) {x : D}
    (hx : IsSelfAdjoint x) (hxn : ‖x‖ ≤ 1) {f : ℝ → ℝ} (hfc : Continuous f)
    (hf : ∀ t ∈ Set.Icc (-1:ℝ) 1, 0 ≤ f t) : 0 ≤ cornerCFC hu x f := by
  let a := ProjectionCorner.compress hu x
  let g : ℝ → ℝ := fun t => Real.sqrt (f t)
  let b : ProjectionCorner hu := cfc g a
  have hg : Continuous g := Real.continuous_sqrt.comp hfc
  have hb : IsSelfAdjoint b := cfc_predicate g a
  have he : b*b = cfc f a := by
    dsimp [b]
    rw [←cfc_mul g g a hg.continuousOn hg.continuousOn]
    apply cfc_congr
    intro t ht
    exact Real.mul_self_sqrt (hf t (spectrum_subset_unit_interval
      (compress_selfAdjoint hu hx) ((compress_norm_le hu x).trans hxn) ht))
  have he' : cornerCFC hu x f = star (b:D)*(b:D) := by
    rw [(ProjectionCorner.isSelfAdjoint_coe hu hb).star_eq]
    exact congrArg Subtype.val he.symm
  rw [he']
  exact star_mul_self_nonneg _

omit [PartialOrder D] [StarOrderedRing D] in
lemma cornerCFC_norm_le_one {u : D} (hu : IsStarProjection u) {x : D}
    (hx : IsSelfAdjoint x) (hxn : ‖x‖ ≤ 1) {f : ℝ → ℝ}
    (hf : ∀ t ∈ Set.Icc (-1:ℝ) 1, f t ∈ Set.Icc 0 1) :
    ‖cornerCFC hu x f‖ ≤ 1 := by
  change ‖(cfc f (ProjectionCorner.compress hu x) : ProjectionCorner hu)‖ ≤ 1
  apply norm_cfc_le zero_le_one
  intro t ht
  have h := hf t (spectrum_subset_unit_interval (compress_selfAdjoint hu hx)
    ((compress_norm_le hu x).trans hxn) ht)
  simpa only [Real.norm_eq_abs,abs_of_nonneg h.1] using h.2

omit [PartialOrder D] [StarOrderedRing D] in
lemma localized_cutoff_mem {u : D} (hu : IsStarProjection u) (x : D)
    (f : ℝ → ℝ) (α : ℝ) :
    u*directCutoff α (cornerCFC hu x f)=directCutoff α (cornerCFC hu x f) ∧
    directCutoff α (cornerCFC hu x f)*u=directCutoff α (cornerCFC hu x f) := by
  let a := ProjectionCorner.compress hu x
  let y : ProjectionCorner hu := cfc f a
  have hy : IsSelfAdjoint y := cfc_predicate f a
  have he := ProjectionCorner.coe_cfc hu hy (fun t : ℝ => min (t/α) 1)
    (by fun_prop) (by simp)
  change ((cfc _ y : ProjectionCorner hu) : D) = directCutoff α (cornerCFC hu x f) at he
  rw [←he]
  exact (cfc _ y : ProjectionCorner hu).property

omit [PartialOrder D] [StarOrderedRing D] in
lemma localized_cutoff_compression {u p : D} (hu : IsStarProjection u)
    (hp : IsStarProjection p) {x : D} (hx : IsSelfAdjoint x) (hxn : ‖x‖ ≤ 1)
    {f : ℝ → ℝ} (hf : Continuous f)
    (hf01 : ∀ t ∈ Set.Icc (-1:ℝ) 1, f t ∈ Set.Icc 0 1)
    {α ε μ : ℝ} (hα : 0 < α) (hε : 0 ≤ ε)
    (hsupp : ∀ t ∈ Set.Icc (-1:ℝ) 1, f t ≠ 0 → |t-μ| ≤ ε)
    (hkp : directCutoff α (cornerCFC hu x f)*p=p)
    (hpk : p*directCutoff α (cornerCFC hu x f)=p) :
    u*p=p ∧ p*u=p ∧ ‖p*x*p-μ • p‖ ≤ ε := by
  let a := ProjectionCorner.compress hu x
  let y : ProjectionCorner hu := cfc f a
  let g : ℝ → ℝ := fun t => min (f t/α) 1
  let k : ProjectionCorner hu := cfc g a
  have ha : IsSelfAdjoint a := compress_selfAdjoint hu hx
  have hg : Continuous g := by dsimp [g]; fun_prop
  have hy : IsSelfAdjoint y := cfc_predicate f a
  have hk : (k : D) = directCutoff α (cornerCFC hu x f) := by
    have he := ProjectionCorner.coe_cfc hu hy (fun t : ℝ => min (t/α) 1)
      (by fun_prop) (by simp)
    dsimp [k,g]
    dsimp [y] at he
    rw [←cfc_comp (fun t : ℝ => min (t/α) 1) f a ha (by fun_prop) hf.continuousOn] at he
    exact he
  have hup : u*p=p := by rw [←hkp,←hk,←mul_assoc,k.property.1,hk,hkp]
  have hpu : p*u=p := by rw [←hpk,←hk,mul_assoc,k.property.2,hk,hpk]
  refine ⟨hup,hpu,?_⟩
  let z : ProjectionCorner hu := k*(a-μ • 1)*k
  have hz : z = cfc (fun t : ℝ => g t*(t-μ)*g t) a := by
    dsimp [z,k]
    rw [cfc_mul _ _ a (by fun_prop) hg.continuousOn,
      cfc_mul _ _ a hg.continuousOn (by fun_prop),
      cfc_sub (fun t : ℝ => t) (fun _ : ℝ => μ) a continuous_id.continuousOn continuous_const.continuousOn,
      cfc_id' ℝ a ha,cfc_const μ a ha,Algebra.algebraMap_eq_smul_one]
  have hzn : ‖z‖ ≤ ε := by
    rw [hz]
    apply norm_cfc_le hε
    intro t ht
    have ht' := spectrum_subset_unit_interval ha ((compress_norm_le hu x).trans hxn) ht
    have hg0 : 0 ≤ g t := le_min (div_nonneg (hf01 t ht').1 hα.le) zero_le_one
    have hg1 : g t ≤ 1 := min_le_right _ _
    by_cases hft : f t=0
    · simp [g,hft,hε]
    · rw [Real.norm_eq_abs,abs_mul,abs_mul,abs_of_nonneg hg0]
      exact (mul_le_mul (mul_le_mul hg1 (hsupp t ht' hft) (abs_nonneg _) zero_le_one)
        hg1 hg0 (by positivity)).trans_eq (by ring)
  have he : p*x*p-μ • p = p*(z:D)*p := by
    change p*x*p-μ • p = p*((k:D)*(u*x*u-μ • u)*(k:D))*p
    symm
    calc
      _ = (p*(k:D))*(u*x*u-μ • u)*((k:D)*p) := by simp only [mul_assoc]
      _ = p*(u*x*u-μ • u)*p := by rw [hk,hpk,hkp]
      _ = _ := by
        simp only [mul_sub,sub_mul,mul_smul_comm,smul_mul_assoc,
          ←mul_assoc,hpu,hp.isIdempotentElem.eq]
        rw [mul_assoc (p*x) u p,hup]

  rw [he]
  exact (compress_norm_le hp (z:D)).trans hzn

lemma positiveCut_trace_lower (τ : TracialState D) {y : D} (hy : 0 ≤ y)
    {α : ℝ} (hα : 0 ≤ α) :
    (τ.functional y).re-α ≤ (τ.functional (directPositiveCut α y)).re := by
  have hn : ‖y-directPositiveCut α y‖ ≤ α := by
    rw [directPositiveCut]
    nth_rw 1 [←cfc_id' ℝ y hy.isSelfAdjoint]
    rw [←cfc_sub (fun t : ℝ => t) (fun t : ℝ => max (t-α) 0) y
      continuous_id.continuousOn (by fun_prop)]
    apply norm_cfc_le hα
    intro t ht
    have ht0 := spectrum_nonneg_of_nonneg hy ht
    change |t-max (t-α) 0| ≤ α
    rw [abs_of_nonneg (sub_nonneg.mpr (max_le (sub_le_self _ hα) ht0))]
    exact sub_le_comm.mpr (le_max_left (t-α) 0)
  have ht := (Complex.re_le_norm (τ.functional (y-directPositiveCut α y))).trans
    ((trace_norm_le_norm _ _).trans hn)
  rw [map_sub,Complex.sub_re] at ht
  exact sub_le_comm.mp ht

end DirectComparison

namespace DirectComparison
open Pureness CurrentMain
open scoped ComplexOrder

variable {D : Type*} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]

structure ProjectionPacking (q : D) where
  Index : Type
  [indexFintype : Fintype Index]
  piece : Index → D
  projection : ∀ i, IsStarProjection (piece i)
  orthogonal : Pairwise (fun i j => piece i*piece j=0)
  sum_le : (∑ i, piece i) ≤ q

attribute [instance] ProjectionPacking.indexFintype
namespace ProjectionPacking
variable {q : D} (P : ProjectionPacking q)

def total : D := ∑ i, P.piece i
def residual : D := q-P.total
omit [StarOrderedRing D] in
lemma total_projection : IsStarProjection P.total :=
  orthogonal_projection_sum Finset.univ P.piece (fun i _ => P.projection i)
    (fun _ _ _ _ hij => P.orthogonal hij)
omit [StarOrderedRing D] in
lemma total_le : P.total ≤ q := P.sum_le
lemma piece_le_total (i : P.Index) : P.piece i ≤ P.total :=
  Finset.single_le_sum (fun j _ => (P.projection j).nonneg) (Finset.mem_univ i)
lemma piece_le (i : P.Index) : P.piece i ≤ q := (P.piece_le_total i).trans P.sum_le
lemma residual_projection (hq : IsStarProjection q) : IsStarProjection P.residual :=
  P.total_projection.sub_of_mul_eq_left hq ((P.total_projection.le_iff_mul_eq_left hq).mp P.total_le)
lemma residual_le : P.residual ≤ q := sub_le_self _ P.total_projection.nonneg
omit [StarOrderedRing D] in
lemma total_add_residual : P.total+P.residual=q := by dsimp [residual]; abel
lemma piece_mul_residual (hq : IsStarProjection q) (i : P.Index) :
    P.piece i*P.residual=0 := by
  rw [residual,mul_sub,(P.projection i).le_iff_mul_eq_left hq |>.mp (P.piece_le i),
    (P.projection i).le_iff_mul_eq_left P.total_projection |>.mp (P.piece_le_total i),sub_self]
lemma residual_mul_piece (hq : IsStarProjection q) (i : P.Index) :
    P.residual*P.piece i=0 := by
  have h := congrArg star (P.piece_mul_residual hq i)
  simpa only [star_mul,(P.residual_projection hq).isSelfAdjoint.star_eq,
    (P.projection i).isSelfAdjoint.star_eq,star_zero] using h

def empty (hq : IsStarProjection q) : ProjectionPacking q where
  Index := Empty
  piece := Empty.elim
  projection := by intro i;cases i
  orthogonal := by intro i;cases i
  sum_le := by simpa using hq.nonneg

@[simp] lemma empty_total (hq : IsStarProjection q) : (empty hq).total=0 := by
  change (∑ i : Empty, (Empty.elim i : D)) = 0
  simp
@[simp] lemma empty_residual (hq : IsStarProjection q) : (empty hq).residual=q := by
  simp [residual]

def singleton {p : D} (hp : IsStarProjection p) (hpq : p ≤ q) : ProjectionPacking q where
  Index := Unit
  piece := fun _ => p
  projection := fun _ => hp
  orthogonal := by intro i j hij; exact (hij (Subsingleton.elim i j)).elim
  sum_le := by simpa using hpq
omit [StarOrderedRing D] in
@[simp] lemma singleton_total {p : D} (hp : IsStarProjection p) (hpq : p ≤ q) :
    (singleton hp hpq).total=p := by
  change (∑ _ : Unit, p) = p
  simp

def append (hq : IsStarProjection q) (Q : ProjectionPacking P.residual) : ProjectionPacking q where
  Index := Sum P.Index Q.Index
  piece := Sum.elim P.piece Q.piece
  projection := by intro i;cases i with
    | inl i => exact P.projection i
    | inr i => exact Q.projection i
  orthogonal := by
    intro i j hij
    cases i with
    | inl i =>
      cases j with
      | inl j => exact P.orthogonal (fun h => hij (congrArg Sum.inl h))
      | inr j =>
        have hQ := ((Q.projection j).le_iff_mul_eq_right (P.residual_projection hq)).mp (Q.piece_le j)
        change P.piece i*Q.piece j=0
        rw [←hQ,←mul_assoc,P.piece_mul_residual hq,zero_mul]
    | inr i =>
      cases j with
      | inl j =>
        have hQ := ((Q.projection i).le_iff_mul_eq_left (P.residual_projection hq)).mp (Q.piece_le i)
        change Q.piece i*P.piece j=0
        rw [←hQ,mul_assoc,P.residual_mul_piece hq,mul_zero]
      | inr j => exact Q.orthogonal (fun h => hij (congrArg Sum.inr h))
  sum_le := by
    rw [Fintype.sum_sum_type]
    change P.total+Q.total ≤ q
    exact (add_le_add le_rfl Q.total_le).trans_eq P.total_add_residual

@[simp] lemma append_total (hq : IsStarProjection q) (Q : ProjectionPacking P.residual) :
    (P.append hq Q).total=P.total+Q.total := by
  exact Fintype.sum_sum_type _
lemma append_residual (hq : IsStarProjection q) (Q : ProjectionPacking P.residual) :
    (P.append hq Q).residual=Q.residual := by
  change q-(P.append hq Q).total = (q-P.total)-Q.total
  rw [append_total]; abel
lemma residual_append_le (hq : IsStarProjection q) (Q : ProjectionPacking P.residual) :
    (P.append hq Q).residual ≤ P.residual := by
  rw [append_residual]; exact Q.residual_le
lemma total_le_append (hq : IsStarProjection q) (Q : ProjectionPacking P.residual) :
    P.total ≤ (P.append hq Q).total := by
  rw [append_total]; exact le_add_of_nonneg_right Q.total_projection.nonneg

def refine (Q : ∀ i : P.Index, ProjectionPacking (P.piece i)) : ProjectionPacking q where
  Index := Σ i : P.Index, (Q i).Index
  piece := fun i => (Q i.1).piece i.2
  projection := fun i => (Q i.1).projection i.2
  orthogonal := by
    rintro ⟨i,s⟩ ⟨j,t⟩ hst
    by_cases hij : i=j
    · subst j
      exact (Q i).orthogonal (fun he => hst (congrArg (Sigma.mk i) he))
    · exact mul_eq_zero_of_supports
        (((Q i).projection s).le_iff_mul_eq_left (P.projection i) |>.mp ((Q i).piece_le s))
        (((Q j).projection t).le_iff_mul_eq_right (P.projection j) |>.mp ((Q j).piece_le t))
        (P.orthogonal hij)
  sum_le := by
    rw [Fintype.sum_sigma]
    exact (Finset.sum_le_sum (fun i _ => (Q i).sum_le)).trans P.sum_le
lemma refine_total (Q : ∀ i : P.Index, ProjectionPacking (P.piece i)) :
    (P.refine Q).total = ∑ i, (Q i).total := Fintype.sum_sigma _
lemma refine_residual (Q : ∀ i : P.Index, ProjectionPacking (P.piece i)) :
    (P.refine Q).residual = P.residual+∑ i, (Q i).residual := by
  rw [residual,refine_total,residual]
  simp only [residual,Finset.sum_sub_distrib]
  change q-∑ i, (Q i).total = (q-∑ i,P.piece i)+((∑ i,P.piece i)-(∑ i,(Q i).total))
  abel

end ProjectionPacking
end DirectComparison
end

end OAI